Merge pull request #7 from Never-Over/separate-container-env-from-client-env

Separate env for containers and clients

Author: emdoyle

bridge/framework/base.py

@@ -7,7 +7,7 @@
 
 from bridge.platform import Platform, detect_platform
 from bridge.service.postgres import PostgresService
-from bridge.service.redis import RedisConfig, RedisService
+from bridge.service.redis import RedisService
 
 
 class Framework(Enum):
@@ -66,8 +66,7 @@ def start_local_postgres(self, client: docker.DockerClient) -> None:
         service.start()
 
     def start_local_redis(self, client: docker.DockerClient) -> None:
-        config = RedisConfig()
-        service = RedisService(client=client, config=config)
+        service = RedisService(client=client)
         service.start()
 
     @abstractmethod

bridge/platform/postgres.py

@@ -1,6 +1,32 @@
+import os
+
+from pydantic import BaseModel
+
+from bridge.console import log_warning
 from bridge.platform.base import Platform
-from bridge.platform.render import build_render_postgres_environment
-from bridge.service.postgres import PostgresEnvironment
+
+
+class PostgresEnvironment(BaseModel):
+    user: str = "postgres"
+    password: str = "postgres"
+    db: str = "postgres"
+    host: str = "localhost"
+    port: int = 5432
+
+    @classmethod
+    def from_env(cls):
+        try:
+            port = int(os.environ.get("POSTGRES_PORT", 5432))
+        except ValueError:
+            log_warning("Invalid POSTGRES_PORT; using default value.")
+            port = 5432
+        return cls(
+            user=os.environ.get("POSTGRES_USER", "postgres"),
+            password=os.environ.get("POSTGRES_PASSWORD", "postgres"),
+            db=os.environ.get("POSTGRES_DB", "postgres"),
+            host=os.environ.get("POSTGRES_HOST", "localhost"),
+            port=port,
+        )
 
 
 def build_postgres_environment(platform: Platform) -> PostgresEnvironment:
@@ -10,6 +36,8 @@ def build_postgres_environment(platform: Platform) -> PostgresEnvironment:
         # which runs locally.
         return PostgresEnvironment()
     elif platform == Platform.RENDER:
+        from bridge.platform.render import build_render_postgres_environment
+
         return build_render_postgres_environment()
     elif platform == Platform.UNKNOWN_REMOTE:
         # This will pull from environment variables like POSTGRES_USER, etc.

bridge/platform/redis.py

@@ -1,12 +1,24 @@
+from pydantic import BaseModel
+
 from bridge.platform.base import Platform
-from bridge.platform.render import build_render_redis_environment
-from bridge.service.redis import RedisEnvironment
+
+
+class RedisEnvironment(BaseModel):
+    host: str = "localhost"
+    port: int = 6379
+    db: int = 0
+
+    @property
+    def url(self) -> str:
+        return f"redis://{self.host}:{self.port}"
 
 
 def build_redis_environment(platform: Platform) -> RedisEnvironment:
     if platform == Platform.LOCAL:
         return RedisEnvironment()
     elif platform == Platform.RENDER:
+        from bridge.platform.render import build_render_redis_environment
+
         return build_render_redis_environment()
     else:
         raise NotImplementedError(f"Unsupported platform for Redis: {platform}")

bridge/platform/render/postgres.py

@@ -2,7 +2,7 @@
 
 import dj_database_url
 
-from bridge.service.postgres import PostgresEnvironment
+from bridge.platform.postgres import PostgresEnvironment
 
 
 def build_render_postgres_environment() -> PostgresEnvironment:

bridge/service/docker.py

@@ -1,13 +1,14 @@
 import sys
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
+from typing import TYPE_CHECKING, Generic, TypeVar, Union, cast
 
 import docker
 from docker.models.containers import Container
-from pydantic import BaseModel, Extra, Field
+from pydantic import BaseModel, Field
 from rich.console import Console
 
 from bridge.console import log_error, log_task
+from bridge.utils.pydantic import Empty
 
 if TYPE_CHECKING:
     import docker.errors
@@ -23,18 +24,10 @@ def get_docker_client() -> docker.DockerClient:
     return client
 
 
-class BaseEnvironment(BaseModel):
-    def to_container_run_kwargs(self) -> dict[str, Any]:
-        return self.model_dump()
+T_BaseModel = TypeVar("T_BaseModel", bound=BaseModel)
 
-    class Config:
-        extra = Extra.allow
 
-
-T_Environment = TypeVar("T_Environment", bound=BaseEnvironment)
-
-
-class ContainerConfig(BaseModel, Generic[T_Environment]):
+class ContainerConfig(BaseModel, Generic[T_BaseModel]):
     """
     Container configuration information.
 
@@ -44,15 +37,9 @@ class ContainerConfig(BaseModel, Generic[T_Environment]):
     image: str
     name: str
     ports: dict[str, int] = Field(default_factory=dict)
-    volumes: dict[str, str] = Field(default_factory=dict)
+    volumes: dict[str, Union[list[str], dict[str, str]]] = Field(default_factory=dict)
     restart_policy: dict[str, str] = {"Name": "always"}
-    environment: T_Environment = Field(default_factory=BaseEnvironment)
-
-    def to_container_run_kwargs(self) -> dict[str, Any]:
-        # Right now the above spec matches `docker.container.run`, model_dump is sufficient
-        dict_rep = self.model_dump()
-        dict_rep["environment"] = self.environment.to_container_run_kwargs()
-        return dict_rep
+    environment: T_BaseModel = Field(default_factory=Empty)
 
 
 T_ContainerConfig = TypeVar("T_ContainerConfig", bound=ContainerConfig)
@@ -101,7 +88,7 @@ def start_container(self):
                     container.restart()
             else:
                 self.client.containers.run(
-                    **self.config.to_container_run_kwargs(),
+                    **self.config.model_dump(),
                     detach=True,
                 )
 

bridge/service/postgres.py

@@ -1,56 +1,36 @@
-import os
 from time import sleep
 from typing import Optional, Union
 
 import docker
 import psycopg
-from pydantic import Field
+from pydantic import BaseModel, Field
 
 from bridge.console import log_task
-from bridge.service.docker import BaseEnvironment, ContainerConfig, DockerService
+from bridge.service.docker import ContainerConfig, DockerService
 from bridge.utils.filesystem import resolve_dot_bridge
 
 
-class PostgresEnvironment(BaseEnvironment):
-    user: str = "postgres"
-    password: str = "postgres"
-    db: str = "postgres"
-    host: str = "localhost"
-    port: Union[int, str] = "5432"
-
-    @classmethod
-    def from_env(cls):
-        return cls(
-            user=os.environ.get("POSTGRES_USER", "postgres"),
-            password=os.environ.get("POSTGRES_PASSWORD", "postgres"),
-            db=os.environ.get("POSTGRES_DB", "postgres"),
-            host=os.environ.get("POSTGRES_HOST", "localhost"),
-            port=os.environ.get("POSTGRES_PORT", "5432"),
-        )
-
-    def to_container_run_kwargs(self) -> dict[str, Union[int, str]]:
-        return {
-            "POSTGRES_USER": self.user,
-            "POSTGRES_PASSWORD": self.password,
-            "POSTGRES_DB": self.db,
-            "POSTGRES_HOST": self.host,
-            "POSTGRES_PORT": self.port,
-        }
+class PostgresEnvironment(BaseModel):
+    POSTGRES_USER: str = "postgres"
+    POSTGRES_PASSWORD: str = "postgres"
+    POSTGRES_DB: str = "postgres"
+    POSTGRES_HOST: str = "localhost"
+    POSTGRES_PORT: str = "5432"
 
 
 class PostgresConfig(ContainerConfig[PostgresEnvironment]):
     image: str = "postgres:12"
     name: str = "bridge_postgres"
     ports: dict[str, int] = {"5432/tcp": 5432}
-    volumes: dict[str, str] = Field(
+    volumes: dict[str, Union[list[str], dict[str, str]]] = Field(
         default_factory=lambda: {
             f"{resolve_dot_bridge()}/pgdata": {
                 "bind": "/var/lib/postgresql/data",
                 "mode": "rw",
             }
         }
     )
-    environment: PostgresEnvironment = PostgresEnvironment()
+    environment: PostgresEnvironment = Field(default_factory=PostgresEnvironment)
 
 
 class PostgresService(DockerService[PostgresConfig]):
@@ -61,11 +41,11 @@ def __init__(
 
     def ensure_ready(self):
         dsn = (
-            f"dbname={self.config.environment.db} "
-            f"user={self.config.environment.user} "
-            f"password={self.config.environment.password} "
-            f"host={self.config.environment.host} "
-            f"port={self.config.environment.port}"
+            f"dbname={self.config.environment.POSTGRES_DB} "
+            f"user={self.config.environment.POSTGRES_USER} "
+            f"password={self.config.environment.POSTGRES_PASSWORD} "
+            f"host={self.config.environment.POSTGRES_HOST} "
+            f"port={self.config.environment.POSTGRES_PORT}"
         )
         with log_task(
             start_message=f"Waiting for [white]{self.config.name}[/white] to be ready",

bridge/service/redis.py

@@ -1,32 +1,26 @@
 from time import sleep
+from typing import Optional
 
 import docker
 import redis
 
 from bridge.console import log_task
-from bridge.service.docker import BaseEnvironment, ContainerConfig, DockerService
+from bridge.platform.redis import RedisEnvironment
+from bridge.service.docker import ContainerConfig, DockerService
 
 
-class RedisEnvironment(BaseEnvironment):
-    host: str = "localhost"
-    port: int = 6379
-    db: int = 0
-
-    @property
-    def url(self) -> str:
-        return f"redis://{self.host}:{self.port}"
-
-
-class RedisConfig(ContainerConfig[RedisEnvironment]):
+class RedisConfig(ContainerConfig):
     image: str = "redis:7.2.4"
     name: str = "bridge_redis"
     ports: dict[str, int] = {"6379/tcp": 6379}
-    environment: RedisEnvironment = RedisEnvironment()
 
 
 class RedisService(DockerService[RedisConfig]):
-    def __init__(self, client: docker.DockerClient, config: RedisConfig) -> None:
-        super().__init__(client, config)
+    def __init__(
+        self, client: docker.DockerClient, config: Optional[RedisConfig] = None
+    ) -> None:
+        super().__init__(client, config or RedisConfig())
+        self.redis_client_environment = RedisEnvironment()
 
     def ensure_ready(self):
         with log_task(
@@ -37,8 +31,8 @@ def ensure_ready(self):
                 try:
                     # Attempt to create a connection to Redis
                     r = redis.Redis(
-                        host=self.config.environment.host,
-                        port=self.config.environment.port,
+                        host=self.redis_client_environment.host,
+                        port=self.redis_client_environment.port,
                     )
                     if r.ping():
                         return  # Redis is ready and responding

bridge/utils/pydantic.py

@@ -0,0 +1,4 @@
+from pydantic import BaseModel
+
+
+class Empty(BaseModel): ...