container-hub 0.2.0__py3-none-any.whl

container_hub/__init__.py

@@ -0,0 +1,34 @@
+from .exceptions import InvalidConfiguration
+
+
+def get_backend(settings, prefix="CONTAINER_HUB"):
+    """
+    Get a backend based on simple-settings or Django settings object.
+
+    Uses `CONTAINER_HUB_CARRIER` = ["docker", "kubernetes"] to determine
+    the backend.
+    """
+    if not hasattr(settings, f"{prefix}_CARRIER"):
+        raise InvalidConfiguration(f"{prefix}_CARRIER is a mandatory setting")
+    opt = str(getattr(settings, f"{prefix}_CARRIER")).lower()
+
+    if opt == "docker":
+        from container_hub.carriers.docker.backend import (
+            DockerBackend,
+            DockerBackendConfig,
+        )
+
+        return DockerBackend(DockerBackendConfig.from_settings(settings, prefix))
+    elif opt == "kubernetes":
+        from container_hub.carriers.kubernetes.backend import (
+            KubernetesBackend,
+            KubernetesBackendConfig,
+        )
+
+        return KubernetesBackend(
+            KubernetesBackendConfig.from_settings(settings, prefix)
+        )
+
+    raise InvalidConfiguration(
+        f"Unknown carrier {opt} option, should either be 'docker' or 'kubernetes'"
+    )

container_hub/carriers/docker/backend.py

@@ -0,0 +1,178 @@
+import logging
+from functools import cached_property
+from pathlib import Path
+from typing import Dict, List
+
+from docker import DockerClient
+from docker.errors import APIError, ContainerError, DockerException, NotFound
+from docker.types import Mount
+
+from container_hub.exceptions import CarrierError
+from container_hub.models import ContainerConfig, DockerBackendConfig
+
+logger = logging.getLogger(__name__)
+
+
+class DockerBackend:
+    """
+    Backend for starting Docker instances via Docker
+    """
+
+    def __init__(self, config: DockerBackendConfig):
+        self.config = config
+
+    @cached_property
+    def client(self):
+        return DockerClient(base_url=self.config.client_url)
+
+    def container_hosts(self) -> Dict[str, str]:
+        """
+        Always localhost, so return emtpy dict
+        """
+        return {}
+
+    def container_list(self) -> List[str]:
+        """
+        Returns a list of simulation_ids
+        """
+        lc = self.client.containers.list(filters={"label": "simulation_id"})
+        return [x.name.lstrip("simulation-") for x in lc]
+
+    def container_ips(self) -> Dict[str, str]:
+        """
+        Return list of ip addresses
+        """
+        d = {}
+        containers = self.client.containers.list(filters={"label": "simulation_id"})
+        for container in containers:
+            try:
+                ip_address = container.attrs["NetworkSettings"]["Networks"][
+                    self.config.network_name
+                ]["IPAddress"]
+            except KeyError:
+                continue
+            d[container.name] = ip_address
+        return d
+
+    def up(self, container_config: ContainerConfig) -> str:
+        """
+        Create container based on simulation and threedimodel.
+
+        :returns the container id
+        """
+        name = f"simulation-{container_config.sim_uid}"
+        result_path = container_config.base_result_path / Path(name)
+        labels = dict([(x.name, x.value) for x in container_config.labels])
+        labels.update({"simulation_id": f"{container_config.sim_uid}"})
+
+        _envs = dict([(f"{x.name}", f"{x.value}") for x in container_config.envs])
+        _envs.update({"RESULT_PATH": f"{result_path.as_posix()}"})
+
+        if (
+            container_config.container_log_level is not None
+            and "LOG_LEVEL" not in _envs
+        ):
+            _envs.update(
+                {f"LOG_LEVEL": f"{container_config.container_log_level.value}"}
+            )
+
+        if container_config.debugpy_port is not None:
+            ports = {
+                f"{container_config.debugpy_port}/tcp": container_config.debugpy_port
+            }
+            _envs.update(
+                {f"DEBUGPY": "1", "DEBUGPY_PORT": str(container_config.debugpy_port)}
+            )
+        else:
+            ports = {}
+
+        cmd = (
+            f"python service.py {container_config.redis_host} {container_config.model_config} "
+            f"{container_config.sim_uid} {container_config.sim_ref_datetime.isoformat()} "
+            f"{container_config.end_time} {container_config.duration} {container_config.start_mode} "
+            f"{container_config.pause_timeout} {container_config.max_rate} {container_config.clean_up_files}"
+        )
+
+        skip_model_mount: bool = all(
+            [
+                x
+                for x in [
+                    container_config.gridadmin_download_url,
+                    container_config.tables_download_url,
+                ]
+            ]
+        )
+
+        if container_config.gridadmin_download_url is not None:
+            cmd += f" {container_config.gridadmin_download_url}"
+        if container_config.tables_download_url is not None:
+            cmd += f" {container_config.tables_download_url}"
+
+        logger.debug("cmd %s", cmd)
+        logger.debug("Envs %s", _envs)
+
+        mounts: List[Mount] = []
+        for mount in container_config.mount_points:
+            if skip_model_mount and mount.mount_path == "/models":
+                # Skip mounting models
+                continue
+            mounts.append(
+                Mount(
+                    mount.mount_path,
+                    mount.local_path,
+                    type="bind",
+                    read_only=mount.read_only,
+                )
+            )
+
+        try:
+            container = self.client.containers.run(
+                image=container_config.image_name,
+                command=cmd,
+                name=name,
+                network=self.config.network_name,
+                mounts=mounts,
+                environment=_envs,
+                detach=True,
+                labels=labels,
+                ports=ports,
+            )
+        except (DockerException, APIError, ContainerError) as err:
+            logger.error(err)
+            raise CarrierError(err)
+
+        # double check everything went right
+        try:
+            self.client.containers.get(container.id)
+        except (APIError, NotFound) as err:
+            logger.error(
+                f"simulation container exited prematurely. Could not retrieve "
+                f"the container if though it should be running {err}"
+            )
+            raise CarrierError(err)
+
+        logger.info(f"Started simulation container {container.name}")
+        return container.id
+
+    def down(self, sim_uid: str):
+        try:
+            container = self.client.containers.get(f"simulation-{sim_uid}")
+            container_id = container.id
+        except (APIError, NotFound) as err:
+            logger.error(
+                f"Could not get the simulation container, error message: {err}"
+            )
+            raise CarrierError(err)
+        try:
+            if not self.config.debug:
+                container.remove(force=True)
+            else:
+                container.kill()
+        except APIError as err:
+            logger.error(
+                f"Could not kill/remove the "
+                f"simulation container, error message: {err}"
+            )
+            raise CarrierError(err)
+        logger.info(f"Removed container for simulation {sim_uid}")
+        return container_id

container_hub/carriers/docker/tests/test_docker_backend.py

@@ -0,0 +1,122 @@
+from datetime import datetime
+from unittest.mock import MagicMock, patch
+
+import pytest
+from docker.types import Mount
+
+from container_hub.carriers.docker.backend import DockerBackend
+from container_hub.models import (
+    ContainerConfig,
+    DockerBackendConfig,
+    EnvVar,
+    Label,
+    LogLevel,
+    MountPoint,
+)
+
+
+@pytest.fixture
+def docker_backend():
+    config = DockerBackendConfig(
+        "client_url",
+        "my_network",
+    )
+    return DockerBackend(config)
+
+
+def test_container_list(docker_backend: DockerBackend):
+    with patch("container_hub.carriers.docker.backend.DockerClient") as client:
+        container = MagicMock()
+        container.name = "simulation-112"
+        client().containers.list.return_value = [container]
+        containers = docker_backend.container_list()
+        assert containers == [
+            "112",
+        ]
+
+
+def test_container_ips(docker_backend: DockerBackend):
+    with patch("container_hub.carriers.docker.backend.DockerClient") as client:
+        container = MagicMock()
+        container.name = "simulation-112"
+        container.attrs = {
+            "NetworkSettings": {
+                "Networks": {
+                    docker_backend.config.network_name: {"IPAddress": "127.0.0.1"}
+                }
+            }
+        }
+        client().containers.list.return_value = [container]
+        ip_addresses = docker_backend.container_ips()
+        assert ip_addresses == {"simulation-112": "127.0.0.1"}
+
+
+def test_up(docker_backend: DockerBackend):
+    dt = datetime.now()
+    container_config = ContainerConfig(
+        "my_image",
+        "base_result_path",
+        12,
+        dt,
+        3600,
+        3600,
+        0,
+        "initialize",
+        "/model.ini",
+        2,
+        512,
+        [EnvVar("env", "1")],
+        [Label("name", "value")],
+        0,
+        True,
+        "gridadmin_url",
+        "tables_download_url",
+        [MountPoint("/local", "/mnt", False)],
+        "redis1",
+        LogLevel.debug,
+        5678,
+    )
+    with patch("container_hub.carriers.docker.backend.DockerClient") as client:
+        container = MagicMock()
+        container.id = 10
+        client().containers.run.return_value = container
+        container_id = docker_backend.up(container_config)
+        assert container_id == 10
+
+        # Check all params for DockerClient().containers.run
+        to_check = {
+            "image": "my_image",
+            "command": f"python service.py redis1 /model.ini 12 {dt.isoformat()} 3600 3600 initialize 0 0 True gridadmin_url tables_download_url",
+            "name": "simulation-12",
+            "network": "my_network",
+            "mounts": [
+                Mount(
+                    **{
+                        "target": "/mnt",
+                        "source": "/local",
+                        "type": "bind",
+                        "read_only": False,
+                    }
+                )
+            ],
+            "environment": {
+                "env": "1",
+                "RESULT_PATH": "base_result_path/simulation-12",
+                "LOG_LEVEL": "DEBUG",
+                "DEBUGPY": "1",
+                "DEBUGPY_PORT": "5678",
+            },
+            "ports": {"5678/tcp": 5678},
+            "detach": True,
+            "labels": {"name": "value", "simulation_id": "12"},
+        }
+        assert client().containers.run.call_args[1] == to_check
+
+
+def test_down(docker_backend: DockerBackend):
+    with patch("container_hub.carriers.docker.backend.DockerClient") as client:
+        container = MagicMock()
+        container.id = 112
+        client().containers.get.return_value = container
+        container_id = docker_backend.down("112")
+        assert container_id == 112

container_hub/carriers/kubernetes/backend.py

@@ -0,0 +1,278 @@
+from functools import cached_property
+from typing import Any, Dict, List, Union
+
+from hikaru.model.rel_1_28 import (
+    Affinity,
+    ConfigMapVolumeSource,
+    Container,
+    ContainerPort,
+    EmptyDirVolumeSource,
+    EnvVar,
+    HostAlias,
+    HostPathVolumeSource,
+    Job,
+    JobSpec,
+    LocalObjectReference,
+    NodeAffinity,
+    NodeSelector,
+    NodeSelectorRequirement,
+    NodeSelectorTerm,
+    ObjectMeta,
+    PodSpec,
+    PodTemplateSpec,
+    ResourceRequirements,
+    SecretVolumeSource,
+    Volume,
+    VolumeMount,
+)
+from kubernetes import config as client_config
+from kubernetes.client import (
+    ApiClient,
+    ApiException,
+    BatchV1Api,
+    Configuration,
+    CoreV1Api,
+)
+from kubernetes.client.models import V1DeleteOptions, V1Job, V1JobList, V1JobStatus
+
+from container_hub.exceptions import CarrierError
+from container_hub.models import (
+    KubernetesBackendConfig,
+    KubernetesContainer,
+    KubernetesJobConfig,
+    MountPointType,
+    NodeAffinityConfig,
+)
+
+# Accessing host (laptop) from within k8s cluster
+K3S_HOST_DNS_NAME = "host.k3d.internal"
+MINIKUBE_HOST_DNS_NAME = "host.minikube.internal"
+
+
+class KubernetesBackend:
+    """
+    Backend for starting Docker instances via Docker
+    """
+
+    def __init__(self, config: KubernetesBackendConfig, in_cluster=True):
+        self.config = config
+        self.in_cluster = in_cluster
+
+    @cached_property
+    def configuration(self) -> Configuration:
+        configuration = Configuration(host=self.config.client_url)
+        if self.in_cluster:
+            client_config.load_incluster_config(configuration)
+
+        return configuration
+
+    def container_hosts(self) -> Dict[str, str]:
+        return {}
+
+    def get_job_status(self, job_name: str) -> Dict[str, Any]:
+        """
+        Get a specific pod ip, based on job_name (simulation-xxx)
+        """
+        job: Union[V1Job, None] = None
+        with ApiClient(self.configuration) as api_client:
+            api = BatchV1Api(api_client)
+            try:
+                job: V1Job = api.read_namespaced_job(
+                    job_name, namespace=self.config.namespace
+                )
+            except ApiException:
+                job = None
+
+        if job is None:
+            raise CarrierError("unknown Job")
+
+        if job.status is None:
+            raise CarrierError("Job has no status")
+
+        job_status: V1JobStatus = job.status
+        return job_status.to_dict()
+
+    def pod_ip(self, job_name: str) -> str:
+        """
+        Get a specific pod ip, based on job_name (simulation-xxx)
+        """
+        with ApiClient(self.configuration) as api_client:
+            api = CoreV1Api(api_client)
+            results = api.list_namespaced_pod(
+                namespace=self.config.namespace, label_selector=f"job-name={job_name}"
+            )
+            if len(results.items) != 1:
+                raise CarrierError(f"Incorrect number of pods returned: {results}")
+            return results.items[0].status.pod_ip
+
+    def container_ips(self) -> Dict[str, str]:
+        return {}
+
+    def container_list(self) -> List[str]:
+        with ApiClient(self.configuration) as api_client:
+            jobs: List[Job] = []
+            api = BatchV1Api(api_client)
+            job_list = None
+            while job_list is None or job_list.metadata._continue is not None:
+                job_list: V1JobList = api.list_namespaced_job(
+                    namespace=self.config.namespace
+                )
+                jobs += [x for x in job_list.items]
+        return [
+            job.metadata.name.lstrip("simulation-")
+            for job in jobs
+            if job.metadata.name.startswith("simulation-")
+        ]
+
+    def up(self, job_config: KubernetesJobConfig) -> str:
+        """
+        Create Kubernetes job for simulation
+        """
+        job = get_simulation_job(job_config)
+        with ApiClient(self.configuration) as api_client:
+            job = job.create(namespace=self.config.namespace, client=api_client)
+        return job_config.name
+
+    def down(self, sim_uid: str):
+        """Remove the given app."""
+        name = f"simulation-{sim_uid}"
+        with ApiClient(self.configuration) as api_client:
+            api = BatchV1Api(api_client)
+            api.delete_namespaced_job(
+                namespace=self.config.namespace,
+                name=name,
+                grace_period_seconds=0,
+                propagation_policy="Background",
+                body=V1DeleteOptions(propagation_policy="Background"),
+            )
+
+
+def get_node_affinity(node_affinity_cfg: NodeAffinityConfig) -> Affinity:
+    return Affinity(
+        nodeAffinity=NodeAffinity(
+            requiredDuringSchedulingIgnoredDuringExecution=NodeSelector(
+                nodeSelectorTerms=[
+                    NodeSelectorTerm(
+                        matchExpressions=[
+                            NodeSelectorRequirement(
+                                key=node_affinity_cfg.key,
+                                operator=node_affinity_cfg.operator,
+                                values=node_affinity_cfg.values,
+                            )
+                        ]
+                    )
+                ]
+            )
+        )
+    )
+
+
+def get_simulation_job(cfg: KubernetesJobConfig) -> Job:
+    return Job(
+        apiVersion="batch/v1",
+        kind="Job",
+        metadata=ObjectMeta(
+            name=cfg.name,
+            annotations={x.name: x.value for x in cfg.annotations},
+            labels={"app": cfg.name},
+        ),
+        spec=JobSpec(
+            template=PodTemplateSpec(
+                metadata=ObjectMeta(
+                    annotations={x.name: x.value for x in cfg.annotations},
+                    labels={"app": cfg.name},
+                ),
+                spec=PodSpec(
+                    affinity=get_node_affinity(cfg.node_affinity)
+                    if cfg.node_affinity is not None
+                    else None,
+                    serviceAccountName=cfg.service_account_name,
+                    imagePullSecrets=[
+                        LocalObjectReference(name=cfg.regcred_secret_name)
+                    ]
+                    if cfg.regcred_secret_name is not None
+                    else None,
+                    hostAliases=[
+                        HostAlias(x.ip_address, x.hostnames) for x in cfg.host_aliases
+                    ],
+                    containers=[
+                        get_container(cfg.redis_config),
+                        get_container(cfg.scheduler_config),
+                        get_container(cfg.simulation_config),
+                    ],
+                    volumes=[
+                        Volume(
+                            name=mount.name,
+                            hostPath=HostPathVolumeSource(
+                                path=mount.local_path, type="Directory"
+                            ),
+                        )
+                        for mount in cfg.mount_points
+                        if mount.type == MountPointType.HOSTPATH
+                    ]
+                    + [
+                        Volume(
+                            name=mount.name,
+                            emptyDir=EmptyDirVolumeSource(sizeLimit=mount.size_limit),
+                        )
+                        for mount in cfg.mount_points
+                        if mount.type == MountPointType.EMPTYDIR
+                    ]
+                    + [
+                        Volume(
+                            name=mount.name,
+                            configMap=ConfigMapVolumeSource(name=mount.local_path),
+                        )
+                        for mount in cfg.mount_points
+                        if mount.type == MountPointType.CONFIGMAP
+                    ]
+                    + [
+                        Volume(
+                            name=mount.name,
+                            secret=SecretVolumeSource(secretName=mount.local_path),
+                        )
+                        for mount in cfg.mount_points
+                        if mount.type == MountPointType.SECRET
+                    ],
+                    restartPolicy="Never",
+                ),
+            ),
+            backoffLimit=0,
+            completions=1,
+        ),
+    )
+
+
+def get_container(cfg: KubernetesContainer) -> Container:
+    """
+    Get k8s container API resource
+    """
+    # Might ne needed for local dev:
+    #   hostAliases=[HostAlias(f"{HOST_IP}", ["minio"])],
+
+    return Container(
+        name=cfg.name,
+        image=cfg.image,
+        imagePullPolicy="IfNotPresent",
+        resources=ResourceRequirements(
+            limits=cfg.resources.limits.to_dict(),
+            requests=cfg.resources.requests.to_dict(),
+        )
+        if cfg.resources is not None
+        else ResourceRequirements(),
+        args=cfg.args,
+        env=[
+            EnvVar(
+                name=envvar.name,
+                value=envvar.value,
+            )
+            for envvar in cfg.envs
+        ],
+        volumeMounts=[
+            VolumeMount(
+                mountPath=mount.mount_path, name=mount.name, readOnly=mount.read_only
+            )
+            for mount in cfg.mount_points
+        ],
+        ports=[ContainerPort(containerPort=port) for port in cfg.ports],
+    )

container_hub/carriers/kubernetes/tests/test_kubernetes_backend.py

@@ -0,0 +1,78 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from simple_settings import LazySettings
+
+from container_hub.carriers.kubernetes.backend import KubernetesBackend
+from container_hub.models import KubernetesBackendConfig, KubernetesJobConfig
+
+
+@pytest.fixture
+def kubernetes_backend():
+    config = KubernetesBackendConfig(
+        "http://kubernetes/",
+        "threedi",
+    )
+    return KubernetesBackend(config, in_cluster=False)
+
+
+@pytest.fixture
+def kubernetes_simple_settings():
+    yield LazySettings("tests.test_files.kubernetes_settings")
+
+
+def test_container_list(kubernetes_backend: KubernetesBackend):
+    with patch("container_hub.carriers.kubernetes.backend.ApiClient") as client:
+        job = MagicMock()
+        job.metadata.name = "simulation-112"
+        job_list = MagicMock()
+        job_list.items = [job]
+        job_list.metadata._continue = None
+        client().__enter__().call_api.return_value = job_list
+        hosts = kubernetes_backend.container_list()
+        assert hosts == ["112"]
+
+
+def get_job_status(kubernetes_backend: KubernetesBackend):
+    with patch("container_hub.carriers.kubernetes.backend.ApiClient") as client:
+        job = MagicMock()
+        job.metadata.name = "simulation-112"
+        job.status = MagicMock()
+        job.status.active = 1
+        job.status.succeeded = None
+        job.status.failed = 1
+        client().__enter__().call_api.return_value = job
+        job_status = kubernetes_backend.get_job_status()
+        assert job_status == {"active": 1, "succeeded": None, "failed": 1}
+
+
+def test_pod_ip(kubernetes_backend: KubernetesBackend):
+    with patch("container_hub.carriers.kubernetes.backend.ApiClient") as client:
+        pod = MagicMock()
+        pod.status.pod_ip = "127.0.0.1"
+        pod_list = MagicMock()
+        pod_list.items = [pod]
+        client().__enter__().call_api.return_value = pod_list
+        pod_ip = kubernetes_backend.pod_ip("simulation-1")
+        assert pod_ip == "127.0.0.1"
+
+
+def test_up(kubernetes_backend: KubernetesBackend, kubernetes_simple_settings):
+    job_config = KubernetesJobConfig.from_settings(
+        "simulation-1", kubernetes_simple_settings
+    )
+
+    with patch("container_hub.carriers.kubernetes.backend.ApiClient") as client:
+
+        def call_api(*args, body=None, **kwargs):
+            return (body, 200, {})
+
+        client().__enter__().call_api = call_api
+        name = kubernetes_backend.up(job_config)
+        assert name == "simulation-1"
+
+
+def test_down(kubernetes_backend: KubernetesBackend):
+    with patch("container_hub.carriers.kubernetes.backend.ApiClient") as client:
+        kubernetes_backend.down("simulation-1")
+        client().__enter__().call_api.assert_called()