refactor(infrastructure): complete implementation audit and fixes

- Add missing methods to ContainerService base class (add_port, set_health_check, add_environment, add_volume)
- Create concrete implementations for RedisService and PostgresService
- Fix ServiceFactory to use correct imports and implementations
- Update all module imports to use new directory structure
- Add health_check, command, and profiles instance variables
- Ensure compose config includes all necessary fields
- Remove app-dev profile restriction for DevContainer compatibility

HIGH PRIORITY openai#3 & openai#4 progress:
- Verified all documented classes exist and work
- Fixed docker-compose profile configuration
- All infrastructure Python files now properly implemented

Author: DeanLuus22021994

.devcontainer/infrastructure/cli.py

@@ -9,9 +9,9 @@
 from typing import Optional
 import yaml
 
-from .config import EnvironmentConfig, DockerComposeConfig
-from .factories import ServiceFactory, DaprComponentFactory
-from .dockerfile_builder import DevelopmentDockerfileBuilder, ProductionDockerfileBuilder
+from .core.config import EnvironmentConfig, DockerComposeConfig
+from .factories.service import ServiceFactory, DaprComponentFactory
+from .builders.dockerfile import DevelopmentDockerfileBuilder, ProductionDockerfileBuilder
 
 
 class InfrastructureCLI:

.devcontainer/infrastructure/core/base.py

@@ -54,6 +54,9 @@ def __init__(
         self._volumes = volumes or []
         self._networks: List[str] = []
         self._depends_on: List[str] = []
+        self._health_check: Optional[Any] = None
+        self._command: Optional[List[str]] = None
+        self._profiles: List[str] = []
 
     @property
     def name(self) -> str:
@@ -75,6 +78,27 @@ def add_dependency(self, service: str) -> "ContainerService":
         self._depends_on.append(service)
         return self
 
+    def add_port(self, port: Port) -> "ContainerService":
+        """Add port to service (fluent interface)."""
+        self._ports.append(port)
+        return self
+
+    def set_health_check(self, health_check: Any) -> "ContainerService":
+        """Set health check for service."""
+        self._health_check = health_check
+        return self
+
+    def add_environment(self, key: str, value: str) -> "ContainerService":
+        """Add environment variable."""
+        self._environment[key] = value
+        return self
+
+    def add_volume(self, host_path: str, container_path: str, readonly: bool = False) -> "ContainerService":
+        """Add volume mount."""
+        mode = ":ro" if readonly else ""
+        self._volumes.append(f"{host_path}:{container_path}{mode}")
+        return self
+
     @abstractmethod
     def get_health_check(self) -> Optional[Dict[str, Any]]:
         """Get service health check configuration.
@@ -121,6 +145,14 @@ def to_compose_config(self) -> Dict[str, Any]:
         health_check = self.get_health_check()
         if health_check:
             config["healthcheck"] = health_check
+        elif self._health_check:
+            config["healthcheck"] = self._health_check.to_compose_config()
+
+        if self._command:
+            config["command"] = self._command
+
+        if self._profiles:
+            config["profiles"] = self._profiles
 
         return config
 

.devcontainer/infrastructure/factories/service.py

@@ -7,20 +7,20 @@
 from pathlib import Path
 import yaml
 
-from .base import (
+from ..core.base import (
     ContainerService,
     DatabaseService,
     MessageBrokerService,
     Port,
 )
-from .health_checks import (
+from ..health.checks import (
     HealthCheck,
     HttpHealthCheck,
     RedisHealthCheck,
     PostgresHealthCheck,
     DaprHealthCheck,
 )
-from .config import ServiceConfig, EnvironmentConfig
+from ..core.config import ServiceConfig, EnvironmentConfig
 
 
 class ServiceFactory:
@@ -30,30 +30,36 @@ class ServiceFactory:
     """
 
     @staticmethod
-    def create_redis_service(config: EnvironmentConfig) -> MessageBrokerService:
+    def create_redis_service(config: EnvironmentConfig) -> "RedisService":
         """Create Redis service instance."""
-        service = MessageBrokerService(
+        from ..implementations import RedisService
+
+        service = RedisService(
             name="redis",
             image="redis:7-bookworm",
-            container_name="openai-agents-redis",
+            ports=[Port(container=6379, host=6379)],
         )
 
-        service.add_port(Port(6379, 6379))
         service.set_health_check(RedisHealthCheck(interval="5s", timeout="3s"))
-        service.add_network("openai-agents-network")
+        service.add_network("agents-network")
 
         return service
 
     @staticmethod
-    def create_postgres_service(config: EnvironmentConfig) -> DatabaseService:
+    def create_postgres_service(config: EnvironmentConfig) -> "PostgresService":
         """Create PostgreSQL service instance."""
-        service = DatabaseService(
+        from ..implementations import PostgresService
+
+        service = PostgresService(
             name="postgres",
             image="postgres:16-bookworm",
-            container_name="openai-agents-postgres",
+            database=config.postgres_db,
+            username=config.postgres_user,
+            password=config.postgres_password,
+            ports=[Port(container=5432, host=5432)],
+            init_scripts="./postgres-init",
         )
 
-        service.add_port(Port(5432, 5432))
         service.set_health_check(
             PostgresHealthCheck(
                 user=config.postgres_user,
@@ -62,22 +68,7 @@ def create_postgres_service(config: EnvironmentConfig) -> DatabaseService:
                 timeout="3s",
             )
         )
-        service.add_network("openai-agents-network")
-
-        # Environment variables
-        service.add_environment("POSTGRES_USER", config.postgres_user)
-        service.add_environment("POSTGRES_PASSWORD", config.postgres_password)
-        service.add_environment("POSTGRES_DB", config.postgres_db)
-
-        # Volume for data persistence
-        service.add_volume("postgres-data", "/var/lib/postgresql/data")
-
-        # Initialization scripts
-        service.add_volume(
-            "./postgres-init:/docker-entrypoint-initdb.d",
-            "/docker-entrypoint-initdb.d",
-            readonly=True,
-        )
+        service.add_network("agents-network")
 
         return service
 
@@ -87,40 +78,37 @@ def create_dapr_sidecar_service(config: EnvironmentConfig) -> ContainerService:
         service = ContainerService(
             name="dapr-sidecar",
             image="daprio/daprd:1.16.0",
-            container_name="openai-agents-dapr-sidecar",
         )
 
         # Dapr ports
-        service.add_port(Port(3500, 3500))  # HTTP
-        service.add_port(Port(50001, 50001))  # gRPC
+        service.add_port(Port(container=3500, host=3500))  # HTTP
+        service.add_port(Port(container=50001, host=50001))  # gRPC
 
         # Health check
         service.set_health_check(
             DaprHealthCheck(interval="10s", timeout="5s", retries=10)
         )
 
-        service.add_network("openai-agents-network")
+        service.add_network("agents-network")
 
         # Dependencies
         service.add_dependency("redis")
         service.add_dependency("postgres")
-        service.add_dependency("dapr-placement")
 
         # Command
         service._command = [
             "./daprd",
-            "--app-id", "openai-agents",
-            "--app-port", "8000",
-            "--dapr-http-port", str(config.dapr_http_port),
-            "--dapr-grpc-port", str(config.dapr_grpc_port),
-            "--resources-path", "/dapr/components",
-            "--config", "/dapr/components/configuration.yaml",
+            "-app-id", "openai-agents",
+            "-dapr-http-port", str(config.dapr_http_port),
+            "-dapr-grpc-port", str(config.dapr_grpc_port),
+            "-components-path", "/components",
+            "-log-level", "info",
         ]
 
         # Volume for Dapr components
         service.add_volume(
-            "./.devcontainer/dapr-components:/dapr/components",
-            "/dapr/components",
+            "./.devcontainer/dapr-components",
+            "/components",
             readonly=True,
         )
 
@@ -132,17 +120,16 @@ def create_dapr_placement_service() -> ContainerService:
         service = ContainerService(
             name="dapr-placement",
             image="daprio/dapr:1.16.0",
-            container_name="openai-agents-dapr-placement",
         )
 
-        service.add_port(Port(50005, 50005))
-        service.add_network("openai-agents-network")
+        service.add_port(Port(container=50006, host=50006))
+        service.add_network("agents-network")
 
         # Run only with actors profile
         service._profiles = ["actors"]
 
         # Command for placement service
-        service._command = ["./placement"]
+        service._command = ["./placement", "-port", "50006"]
 
         return service
 

.devcontainer/infrastructure/implementations/__init__.py

@@ -0,0 +1,9 @@
+"""Concrete implementations of container services.
+
+Provides specific implementations for Redis, PostgreSQL, and other services.
+"""
+
+from .redis import RedisService
+from .postgres import PostgresService
+
+__all__ = ["RedisService", "PostgresService"]

.devcontainer/infrastructure/implementations/postgres.py

@@ -0,0 +1,37 @@
+"""PostgreSQL service implementation."""
+
+from typing import Dict, Any, Optional, List
+from ..core.base import DatabaseService, Port
+
+
+class PostgresService(DatabaseService):
+    """PostgreSQL database service."""
+
+    def get_health_check(self) -> Optional[Dict[str, Any]]:
+        """Get PostgreSQL health check configuration."""
+        # Health check is set via set_health_check() in factory
+        return None
+
+    def get_default_environment(self) -> Dict[str, str]:
+        """Get default PostgreSQL environment variables."""
+        return {
+            "POSTGRES_USER": self._username,
+            "POSTGRES_PASSWORD": self._password,
+            "POSTGRES_DB": self._database,
+        }
+
+    def _build_connection_string(self) -> str:
+        """Build PostgreSQL connection string."""
+        return (
+            f"host=postgres user={self._username} "
+            f"password={self._password} "
+            f"dbname={self._database} port=5432"
+        )
+
+    def _get_init_path(self) -> str:
+        """Get initialization scripts path in container."""
+        return "/docker-entrypoint-initdb.d"
+
+    def _get_data_path(self) -> str:
+        """Get data persistence path in container."""
+        return "/var/lib/postgresql/data"

.devcontainer/infrastructure/implementations/redis.py

@@ -0,0 +1,43 @@
+"""Redis service implementation."""
+
+from typing import Dict, Any, Optional, List
+from ..core.base import MessageBrokerService, Port
+
+
+class RedisService(MessageBrokerService):
+    """Redis message broker and state store service."""
+
+    def __init__(
+        self,
+        name: str = "redis",
+        image: str = "redis:7-bookworm",
+        ports: Optional[List[Port]] = None,
+        persistence: bool = True,
+    ):
+        """Initialize Redis service.
+
+        Args:
+            name: Service name
+            image: Docker image
+            ports: Port mappings
+            persistence: Enable data persistence
+        """
+        super().__init__(name, image, ports, persistence)
+
+    def get_health_check(self) -> Optional[Dict[str, Any]]:
+        """Get Redis health check configuration."""
+        # Health check is set via set_health_check() in factory
+        return None
+
+    def get_default_environment(self) -> Dict[str, str]:
+        """Get default Redis environment variables."""
+        return {}
+
+    def get_persistence_config(self) -> Optional[Dict[str, Any]]:
+        """Get Redis persistence configuration."""
+        if not self._persistence:
+            return None
+
+        return {
+            "volumes": [f"{self._name}-data:/data"],
+        }

.devcontainer/infrastructure/testing/fixtures.py

@@ -9,10 +9,10 @@
 import tempfile
 import shutil
 
-from .config import EnvironmentConfig, ServiceConfig, DockerComposeConfig
-from .factories import ServiceFactory, DaprComponentFactory
-from .health_checks import RedisHealthCheck, PostgresHealthCheck
-from .dockerfile_builder import DevelopmentDockerfileBuilder, ProductionDockerfileBuilder
+from ..core.config import EnvironmentConfig, ServiceConfig, DockerComposeConfig
+from ..factories.service import ServiceFactory, DaprComponentFactory
+from ..health.checks import RedisHealthCheck, PostgresHealthCheck
+from ..builders.dockerfile import DevelopmentDockerfileBuilder, ProductionDockerfileBuilder
 
 
 @pytest.fixture

docker-compose.yml

@@ -11,8 +11,6 @@ services:
       context: .
       dockerfile: Dockerfile.dev
     container_name: openai-agents-dev
-    profiles:
-      - dev
     volumes:
       - .:/workspace:cached
       - /var/run/docker.sock:/var/run/docker.sock