stacks.py

from cdktf import TerraformStack, TerraformOutput
from constructs import Construct
from cdktf_cdktf_provider_docker.provider import DockerProvider
from cdktf_cdktf_provider_kubernetes.provider import KubernetesProvider
from cdktf_cdktf_provider_docker.container import Container
from cdktf_cdktf_provider_docker.image import Image
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


class BaseTerraformStack(TerraformStack):
    """Stack base — provê estrutura comum e hooks de provisionamento"""

    def __init__(self, scope: Construct, id: str, name: str, provider: str,
                 nginx_image: str, internal_port: int, external_port: int):
        super().__init__(scope, id)

        # Validação de entrada
        if not name or " " in name:
            raise ValueError("O nome do stack não pode estar vazio nem conter espaços.")
        if internal_port <= 0 or external_port <= 0:
            raise ValueError("As portas devem ser maiores que zero.")

        self.name = name
        self.provider = provider
        self.nginx_image = nginx_image
        self.internal_port = internal_port
        self.external_port = external_port

        self._setup_provider()
        self._create_resources()
        self._create_outputs()

    def _setup_provider(self):
        """Inicializa provider (Docker ou Kind)"""
        providers = {
            "docker": lambda: DockerProvider(self, "docker"),
            "kind": lambda: KubernetesProvider(self, "kind", config_path="~/.kube/config")
        }
        provider_fn = providers.get(self.provider)
        if not provider_fn:
            raise ValueError(f"Provider '{self.provider}' não suportado.")
        self.provider_instance = provider_fn()
        logger.info(f"Provider {self.provider} inicializado com sucesso")

    def _create_resources(self):
        """Provisiona recursos padrão"""
        if self.provider == "docker":
            self._create_docker_resources()
        elif self.provider == "kind":
            self._create_kubernetes_resources()

    def _create_docker_resources(self):
        """Recursos Docker"""
        logger.info(f"[{self.name}] Criando container Docker...")
        self.docker_image = Image(self, f"{self.name}_image",
                                  name=self.nginx_image, keep_locally=False)
        self.docker_container = Container(self, f"{self.name}_container",
                                          name=f"{self.name}_container",
                                          image=self.docker_image.image_id,
                                          ports=[{"internal": self.internal_port, "external": self.external_port}],
                                          env=[])
        logger.info(f"[{self.name}] Container criado com sucesso")

    def _create_kubernetes_resources(self):
        """Recursos Kubernetes (Kind)"""
        from cdktf_cdktf_provider_kubernetes.deployment import Deployment
        self. Deployment(self, f"{self.name}_deployment",
            metadata={"name": f"{self.name}-deploy"},
            spec={
                "selector": {"match_labels": {"app": self.name}},
                "template": {
                    "metadata": {"labels": {"app": self.name}},
                    "spec": {
                        "container": [{
                            "name": self.name,
                            "image": self.nginx_image,
                            "ports": [{"container_port": self.internal_port}]
                        }]
                    }
                }
            }
        )

    def _create_outputs(self):
        """Exibe outputs úteis"""
        TerraformOutput(self, "application_name", value=self.name)
        TerraformOutput(self, "provider", value=self.provider)
        TerraformOutput(self, "image", value=self.nginx_image)


class Api(BaseTerraformStack):
    """Stack para aplicação do tipo API"""
    def _create_resources(self):
        super()._create_resources()
        if hasattr(self, 'docker_container'):
            self.docker_container.env = ["API_MODE=true"]


class Worker(BaseTerraformStack):
    """Stack para aplicação do tipo Worker"""
    def _create_resources(self):
        super()._create_resources()
        if hasattr(self, 'docker_container'):
            self.docker_container.env = ["WORKER_MODE=true"]


class Service(BaseTerraformStack):
    """Stack para aplicação do tipo Service"""
    def _create_resources(self):
        super()._create_resources()
        if hasattr(self, 'docker_container'):
            self.docker_container.env = ["SERVICE_MODE=true"]


STACK_CLASSES = {"api": Api, "worker": Worker, "service": Service}