dbt-platform-helper 15.0.0__py3-none-any.whl → 15.2.0__py3-none-any.whl

dbt_platform_helper/domain/codebase.py

@@ -167,13 +167,16 @@ class Codebase:
 
         image_ref = None
         if commit:
-            image_ref = f"commit-{commit[0:7]}"
+            self._validate_sha_length(commit)
+            image_ref = f"commit-{commit}"
         elif tag:
             image_ref = f"tag-{tag}"
         elif branch:
             image_ref = f"branch-{branch}"
-        image_details = self.ecr_provider.get_image_details(application, codebase, image_ref)
-        image_ref = self.ecr_provider.find_commit_tag(image_details, image_ref)
+
+        image_ref = self.ecr_provider.get_commit_tag_for_reference(
+            application.name, codebase, image_ref
+        )
 
         codepipeline_client = session.client("codepipeline")
         pipeline_name = self.get_manual_release_pipeline(codepipeline_client, app, codebase)
@@ -284,6 +287,12 @@ class Codebase:
             return get_build_url_from_pipeline_execution_id(execution_id, build_options["name"])
         return None
 
+    def _validate_sha_length(self, commit):
+        if len(commit) < 7:
+            self.io.abort_with_error(
+                "Your commit reference is too short. Commit sha hashes specified by '--commit' must be at least 7 characters long."
+            )
+
 
 class ApplicationDeploymentNotTriggered(PlatformException):
     def __init__(self, codebase: str):

dbt_platform_helper/domain/conduit.py

@@ -1,119 +1,365 @@
-import subprocess
+from abc import ABC
+from abc import abstractmethod
+from typing import Callable
+from typing import Optional
 
 from dbt_platform_helper.providers.cloudformation import CloudFormation
+from dbt_platform_helper.providers.copilot import _normalise_secret_name
 from dbt_platform_helper.providers.copilot import connect_to_addon_client_task
 from dbt_platform_helper.providers.copilot import create_addon_client_task
+from dbt_platform_helper.providers.copilot import get_postgres_admin_connection_string
 from dbt_platform_helper.providers.ecs import ECS
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.secrets import Secrets
+from dbt_platform_helper.providers.vpc import VpcProvider
 from dbt_platform_helper.utils.application import Application
 
 
-class Conduit:
+class ConduitECSStrategy(ABC):
+    @abstractmethod
+    def get_data(self):
+        pass
+
+    @abstractmethod
+    def start_task(self, data_context: dict):
+        pass
+
+    @abstractmethod
+    def exec_task(self, data_context: dict):
+        pass
+
+
+class TerraformConduitStrategy(ConduitECSStrategy):
     def __init__(
         self,
+        clients,
+        ecs_provider: ECS,
         application: Application,
+        addon_name: str,
+        addon_type: str,
+        access: str,
+        env: str,
+        io: ClickIOProvider,
+        vpc_provider: Callable,
+        get_postgres_admin_connection_string: Callable,
+    ):
+        self.clients = clients
+        self.ecs_provider = ecs_provider
+        self.io = io
+        self.vpc_provider = vpc_provider
+        self.access = access
+        self.addon_name = addon_name
+        self.addon_type = addon_type
+        self.application = application
+        self.env = env
+        self.get_postgres_admin_connection_string = get_postgres_admin_connection_string
+
+    def get_data(self):
+        self.io.info("Starting conduit in Terraform mode.")
+        return {
+            "cluster_arn": self.ecs_provider.get_cluster_arn_by_name(
+                f"{self.application.name}-{self.env}"
+            ),
+            "task_def_family": self._generate_container_name(),
+            "vpc_name": self._resolve_vpc_name(),
+            "addon_type": self.addon_type,
+            "access": self.access,
+        }
+
+    def start_task(self, data_context: dict):
+
+        environments = self.application.environments
+        environment = environments.get(self.env)
+        env_session = environment.session
+
+        vpc_provider = self.vpc_provider(env_session)
+        vpc_config = vpc_provider.get_vpc(
+            self.application.name,
+            self.env,
+            data_context["vpc_name"],
+        )
+
+        postgres_admin_env_vars = None
+        if data_context["addon_type"] == "postgres" and data_context["access"] == "admin":
+            postgres_admin_env_vars = [
+                {
+                    "name": "CONNECTION_SECRET",
+                    "value": self.get_postgres_admin_connection_string(
+                        self.clients.get("ssm"),
+                        f"/copilot/{self.application.name}/{self.env}/secrets/{_normalise_secret_name(self.addon_name)}",
+                        self.application,
+                        self.env,
+                        self.addon_name,
+                    ),
+                },
+            ]
+
+        self.ecs_provider.start_ecs_task(
+            f"{self.application.name}-{self.env}",
+            self._generate_container_name(),
+            data_context["task_def_family"],
+            vpc_config,
+            postgres_admin_env_vars,
+        )
+
+    def exec_task(self, data_context: dict):
+        self.ecs_provider.exec_task(data_context["cluster_arn"], data_context["task_arns"][0])
+
+    def _generate_container_name(self):
+        return f"conduit-{self.addon_type}-{self.access}-{self.application.name}-{self.env}-{self.addon_name}"
+
+    def _resolve_vpc_name(self):
+        ssm_client = self.clients["ssm"]
+        parameter_key = f"/conduit/{self.application.name}/{self.env}/{_normalise_secret_name(self.addon_name)}_VPC_NAME"
+
+        try:
+            response = ssm_client.get_parameter(Name=parameter_key)
+            return response["Parameter"]["Value"]
+        except ssm_client.exceptions.ParameterNotFound:
+            self.io.abort_with_error(
+                f"Could not find VPC name for {self.addon_name}. Missing SSM param: {parameter_key}"
+            )
+
+
+class CopilotConduitStrategy(ConduitECSStrategy):
+    def __init__(
+        self,
+        clients,
+        ecs_provider: ECS,
         secrets_provider: Secrets,
         cloudformation_provider: CloudFormation,
-        ecs_provider: ECS,
-        io: ClickIOProvider = ClickIOProvider(),
-        subprocess: subprocess = subprocess,
-        connect_to_addon_client_task=connect_to_addon_client_task,
-        create_addon_client_task=create_addon_client_task,
+        application: Application,
+        addon_name: str,
+        access: str,
+        env: str,
+        io: ClickIOProvider,
+        connect_to_addon_client_task: Callable,
+        create_addon_client_task: Callable,
     ):
-
-        self.application = application
-        self.secrets_provider = secrets_provider
+        self.clients = clients
         self.cloudformation_provider = cloudformation_provider
         self.ecs_provider = ecs_provider
-        self.subprocess = subprocess
+        self.secrets_provider = secrets_provider
+
         self.io = io
+        self.access = access
+        self.addon_name = addon_name
+        self.application = application
+        self.env = env
         self.connect_to_addon_client_task = connect_to_addon_client_task
         self.create_addon_client_task = create_addon_client_task
 
-    def start(self, env: str, addon_name: str, access: str = "read"):
-        clients = self._initialise_clients(env)
-        addon_type, cluster_arn, parameter_name, task_name = self._get_addon_details(
-            addon_name, access
+    def get_data(self):
+
+        addon_type = self.secrets_provider.get_addon_type(self.addon_name)
+        parameter_name = self.secrets_provider.get_parameter_name(
+            addon_type, self.addon_name, self.access
         )
+        task_name = self.ecs_provider.get_or_create_task_name(self.addon_name, parameter_name)
 
-        self.io.info(f"Checking if a conduit task is already running for {addon_type}")
-        task_arns = self.ecs_provider.get_ecs_task_arns(cluster_arn, task_name)
-        if not task_arns:
-            self.io.info("Creating conduit task")
-            self.create_addon_client_task(
-                clients["iam"],
-                clients["ssm"],
-                self.subprocess,
-                self.application,
-                env,
-                addon_type,
+        return {
+            "cluster_arn": self.ecs_provider.get_cluster_arn_by_copilot_tag(),
+            "addon_type": addon_type,
+            "task_def_family": f"copilot-{task_name}",
+            "parameter_name": parameter_name,
+            "task_name": task_name,
+        }
+
+    def start_task(self, data_context: dict):
+        self.create_addon_client_task(
+            self.clients["iam"],
+            self.clients["ssm"],
+            self.application,
+            self.env,
+            data_context["addon_type"],
+            self.addon_name,
+            data_context["task_name"],
+            self.access,
+        )
+
+        self.io.info("Updating conduit task")
+        self.cloudformation_provider.add_stack_delete_policy_to_task_role(data_context["task_name"])
+        stack_name = self.cloudformation_provider.update_conduit_stack_resources(
+            self.application.name,
+            self.env,
+            data_context["addon_type"],
+            self.addon_name,
+            data_context["task_name"],
+            data_context["parameter_name"],
+            self.access,
+        )
+        self.io.info("Waiting for conduit task update to complete...")
+        self.cloudformation_provider.wait_for_cloudformation_to_reach_status(
+            "stack_update_complete", stack_name
+        )
+
+    def exec_task(self, data_context: dict):
+        self.connect_to_addon_client_task(
+            self.clients["ecs"],
+            self.application.name,
+            self.env,
+            data_context["cluster_arn"],
+            data_context["task_name"],
+        )
+
+
+class ConduitStrategyFactory:
+
+    @staticmethod
+    def detect_mode(
+        ecs_client,
+        application,
+        environment,
+        addon_name: str,
+        addon_type: str,
+        access: str,
+        io: ClickIOProvider,
+    ) -> str:
+        """Detect if Terraform-based conduit task definitions are present,
+        otherwise default to Copilot mode."""
+        paginator = ecs_client.get_paginator("list_task_definitions")
+        prefix = f"conduit-{addon_type}-{access}-{application}-{environment}-{addon_name}"
+
+        for page in paginator.paginate():
+            for arn in page["taskDefinitionArns"]:
+                if arn.split("/")[-1].startswith(prefix):
+                    return "terraform"
+
+        io.info("Defaulting to copilot mode.")
+        return "copilot"
+
+    @staticmethod
+    def create_strategy(
+        mode: str,
+        clients,
+        ecs_provider: ECS,
+        secrets_provider: Secrets,
+        cloudformation_provider: CloudFormation,
+        application: Application,
+        addon_name: str,
+        addon_type: str,
+        access: str,
+        env: str,
+        io: ClickIOProvider,
+    ):
+
+        if mode == "terraform":
+            return TerraformConduitStrategy(
+                clients,
+                ecs_provider,
+                application,
                 addon_name,
-                task_name,
+                addon_type,
                 access,
-            )
-
-            self.io.info("Updating conduit task")
-            self._update_stack_resources(
-                self.application.name,
                 env,
-                addon_type,
+                io,
+                vpc_provider=VpcProvider,
+                get_postgres_admin_connection_string=get_postgres_admin_connection_string,
+            )
+        else:
+            return CopilotConduitStrategy(
+                clients,
+                ecs_provider,
+                secrets_provider,
+                cloudformation_provider,
+                application,
                 addon_name,
-                task_name,
-                parameter_name,
                 access,
+                env,
+                io,
+                connect_to_addon_client_task=connect_to_addon_client_task,
+                create_addon_client_task=create_addon_client_task,
             )
 
-            task_arns = self.ecs_provider.get_ecs_task_arns(cluster_arn, task_name)
 
-        else:
-            self.io.info("Conduit task already running")
+class Conduit:
+    def __init__(
+        self,
+        application: Application,
+        secrets_provider: Secrets,
+        cloudformation_provider: CloudFormation,
+        ecs_provider: ECS,
+        io: ClickIOProvider = ClickIOProvider(),
+        vpc_provider=VpcProvider,
+        strategy_factory: Optional[ConduitStrategyFactory] = None,
+    ):
+
+        self.application = application
+        self.secrets_provider = secrets_provider
+        self.cloudformation_provider = cloudformation_provider
+        self.ecs_provider = ecs_provider
+        self.io = io
+        self.vpc_provider = vpc_provider
+        self.strategy_factory = strategy_factory or ConduitStrategyFactory()
 
-        self.io.info(f"Checking if exec is available for conduit task...")
+    def start(self, env: str, addon_name: str, access: str = "read"):
+        self.clients = self._initialise_clients(env)
+        addon_type = self.secrets_provider.get_addon_type(addon_name)
 
-        self.ecs_provider.ecs_exec_is_available(cluster_arn, task_arns)
+        if (addon_type == "opensearch" or addon_type == "redis") and (access != "read"):
+            access = "read"
 
-        self.io.info("Connecting to conduit task")
-        self.connect_to_addon_client_task(
-            clients["ecs"], self.subprocess, self.application.name, env, cluster_arn, task_name
+        mode = self.strategy_factory.detect_mode(
+            self.clients.get("ecs"),
+            self.application.name,
+            env,
+            addon_name,
+            addon_type,
+            access,
+            self.io,
+        )
+
+        strategy = self.strategy_factory.create_strategy(
+            mode=mode,
+            clients=self.clients,
+            ecs_provider=self.ecs_provider,
+            secrets_provider=self.secrets_provider,
+            cloudformation_provider=self.cloudformation_provider,
+            application=self.application,
+            addon_name=addon_name,
+            addon_type=addon_type,
+            access=access,
+            env=env,
+            io=self.io,
+        )
+
+        data_context = strategy.get_data()
+
+        data_context["task_arns"] = self.ecs_provider.get_ecs_task_arns(
+            data_context["cluster_arn"], data_context["task_def_family"]
+        )
+
+        info_log = (
+            f"Checking if a conduit ECS task is already running for:\n"
+            f"  Addon Name : {addon_name}\n"
+            f"  Addon Type : {addon_type}"
         )
 
+        if addon_type == "postgres":
+            info_log += f"\n  Access Level : {access}"
+
+        self.io.info(info_log)
+
+        if not data_context["task_arns"]:
+            self.io.info("Creating conduit ECS task...")
+            strategy.start_task(data_context)
+            data_context["task_arns"] = self.ecs_provider.wait_for_task_to_register(
+                data_context["cluster_arn"], data_context["task_def_family"]
+            )
+        else:
+            self.io.info(f"Found a task already running: {data_context['task_arns'][0]}")
+
+        self.io.info(f"Waiting for ECS Exec agent to become available on the conduit task...")
+        self.ecs_provider.ecs_exec_is_available(
+            data_context["cluster_arn"], data_context["task_arns"]
+        )
+
+        self.io.info("Connecting to conduit task...")
+        strategy.exec_task(data_context)
+
     def _initialise_clients(self, env):
         return {
             "ecs": self.application.environments[env].session.client("ecs"),
             "iam": self.application.environments[env].session.client("iam"),
             "ssm": self.application.environments[env].session.client("ssm"),
         }
-
-    def _get_addon_details(self, addon_name, access):
-        addon_type = self.secrets_provider.get_addon_type(addon_name)
-        cluster_arn = self.ecs_provider.get_cluster_arn()
-        parameter_name = self.secrets_provider.get_parameter_name(addon_type, addon_name, access)
-        task_name = self.ecs_provider.get_or_create_task_name(addon_name, parameter_name)
-
-        return addon_type, cluster_arn, parameter_name, task_name
-
-    def _update_stack_resources(
-        self,
-        app_name,
-        env,
-        addon_type,
-        addon_name,
-        task_name,
-        parameter_name,
-        access,
-    ):
-        self.cloudformation_provider.add_stack_delete_policy_to_task_role(task_name)
-        stack_name = self.cloudformation_provider.update_conduit_stack_resources(
-            app_name,
-            env,
-            addon_type,
-            addon_name,
-            task_name,
-            parameter_name,
-            access,
-        )
-        self.io.info("Waiting for conduit task update to complete...")
-        self.cloudformation_provider.wait_for_cloudformation_to_reach_status(
-            "stack_update_complete", stack_name
-        )

dbt_platform_helper/domain/config.py

@@ -10,16 +10,16 @@ from dbt_platform_helper.constants import PLATFORM_CONFIG_FILE
 from dbt_platform_helper.domain.versioning import AWSVersioning
 from dbt_platform_helper.domain.versioning import CopilotVersioning
 from dbt_platform_helper.domain.versioning import PlatformHelperVersioning
+from dbt_platform_helper.entities.semantic_version import (
+    IncompatibleMajorVersionException,
+)
+from dbt_platform_helper.entities.semantic_version import SemanticVersion
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.aws.sso_auth import SSOAuthProvider
 from dbt_platform_helper.providers.config import ConfigProvider
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.schema_migrator import ALL_MIGRATIONS
 from dbt_platform_helper.providers.schema_migrator import Migrator
-from dbt_platform_helper.providers.semantic_version import (
-    IncompatibleMajorVersionException,
-)
-from dbt_platform_helper.providers.semantic_version import SemanticVersion
 from dbt_platform_helper.providers.validation import ValidationException
 from dbt_platform_helper.providers.version_status import VersionStatus
 

dbt_platform_helper/domain/versioning.py

@@ -1,15 +1,15 @@
 import os
 
-from dbt_platform_helper.platform_exception import PlatformException
-from dbt_platform_helper.providers.config import ConfigProvider
-from dbt_platform_helper.providers.io import ClickIOProvider
-from dbt_platform_helper.providers.semantic_version import (
+from dbt_platform_helper.entities.semantic_version import (
     IncompatibleMajorVersionException,
 )
-from dbt_platform_helper.providers.semantic_version import (
+from dbt_platform_helper.entities.semantic_version import (
     IncompatibleMinorVersionException,
 )
-from dbt_platform_helper.providers.semantic_version import SemanticVersion
+from dbt_platform_helper.entities.semantic_version import SemanticVersion
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.config import ConfigProvider
+from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.version import AWSCLIInstalledVersionProvider
 from dbt_platform_helper.providers.version import CopilotInstalledVersionProvider
 from dbt_platform_helper.providers.version import GithubLatestVersionProvider

dbt_platform_helper/platform_exception.py

@@ -3,3 +3,7 @@
 # error and abort.
 class PlatformException(Exception):
     pass
+
+
+class ValidationException(PlatformException):
+    pass

dbt_platform_helper/providers/aws/exceptions.py

@@ -12,16 +12,34 @@ class CreateTaskTimeoutException(AWSException):
         )
 
 
+IMAGE_NOT_FOUND_TEMPLATE = """An image labelled "{image_ref}" could not be found in your image repository. Try the `platform-helper codebase build` command first."""
+
+
 class ImageNotFoundException(AWSException):
     def __init__(self, image_ref: str):
+        super().__init__(IMAGE_NOT_FOUND_TEMPLATE.format(image_ref=image_ref))
+
+
+MULTIPLE_IMAGES_FOUND_TEMPLATE = (
+    'Image reference "{image_ref}" is matched by the following images: {matching_images}'
+)
+
+
+class MultipleImagesFoundException(AWSException):
+    def __init__(self, image_ref: str, matching_images: list[str]):
         super().__init__(
-            f"""An image labelled "{image_ref}" could not be found in your image repository. Try the `platform-helper codebase build` command first."""
+            MULTIPLE_IMAGES_FOUND_TEMPLATE.format(
+                image_ref=image_ref, matching_images=", ".join(sorted(matching_images))
+            )
         )
 
 
+REPOSITORY_NOT_FOUND_TEMPLATE = """The ECR repository "{repository}" could not be found."""
+
+
 class RepositoryNotFoundException(AWSException):
     def __init__(self, repository: str):
-        super().__init__(f"""The ECR repository "{repository}" could not be found.""")
+        super().__init__(REPOSITORY_NOT_FOUND_TEMPLATE.format(repository=repository))
 
 
 class LogGroupNotFoundException(AWSException):

dbt_platform_helper/providers/config.py

@@ -8,11 +8,11 @@ from dbt_platform_helper.constants import FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR
 from dbt_platform_helper.constants import PLATFORM_CONFIG_FILE
 from dbt_platform_helper.constants import PLATFORM_CONFIG_SCHEMA_VERSION
 from dbt_platform_helper.constants import PLATFORM_HELPER_PACKAGE_NAME
+from dbt_platform_helper.entities.platform_config_schema import PlatformConfigSchema
+from dbt_platform_helper.entities.semantic_version import SemanticVersion
 from dbt_platform_helper.providers.config_validator import ConfigValidator
 from dbt_platform_helper.providers.config_validator import ConfigValidatorError
 from dbt_platform_helper.providers.io import ClickIOProvider
-from dbt_platform_helper.providers.platform_config_schema import PlatformConfigSchema
-from dbt_platform_helper.providers.semantic_version import SemanticVersion
 from dbt_platform_helper.providers.version import InstalledVersionProvider
 from dbt_platform_helper.providers.yaml_file import FileNotFoundException
 from dbt_platform_helper.providers.yaml_file import FileProviderException

dbt_platform_helper/providers/copilot.py

@@ -1,4 +1,5 @@
 import json
+import subprocess
 import time
 
 from botocore.exceptions import ClientError
@@ -13,7 +14,6 @@ from dbt_platform_helper.utils.messages import abort_with_error
 def create_addon_client_task(
     iam_client,
     ssm_client,
-    subprocess,
     application: Application,
     env: str,
     addon_type: str,
@@ -31,7 +31,6 @@ def create_addon_client_task(
         elif access == "admin":
             create_postgres_admin_task(
                 ssm_client,
-                subprocess,
                 application,
                 addon_name,
                 addon_type,
@@ -71,15 +70,8 @@ def create_addon_client_task(
     )
 
 
-def create_postgres_admin_task(
-    ssm_client,
-    subprocess,
-    app: Application,
-    addon_name: str,
-    addon_type: str,
-    env: str,
-    secret_name: str,
-    task_name: str,
+def get_postgres_admin_connection_string(
+    ssm_client, secret_name: str, app: Application, env: str, addon_name: str
 ):
     read_only_secret_name = secret_name + "_READ_ONLY_USER"
     master_secret_name = (
@@ -94,6 +86,23 @@ def create_postgres_admin_task(
         )
     )
 
+    return connection_string
+
+
+def create_postgres_admin_task(
+    ssm_client,
+    app: Application,
+    addon_name: str,
+    addon_type: str,
+    env: str,
+    secret_name: str,
+    task_name: str,
+):
+
+    connection_string = get_postgres_admin_connection_string(
+        ssm_client, secret_name, app, env, addon_name
+    )
+
     subprocess.call(
         f"copilot task run --app {app.name} --env {env} "
         f"--task-group-name {task_name} "
@@ -121,7 +130,6 @@ def _temp_until_refactor_get_ecs_task_arns(ecs_client, cluster_arn: str, task_na
 
 def connect_to_addon_client_task(
     ecs_client,
-    subprocess,
     application_name,
     env,
     cluster_arn,

dbt_platform_helper/providers/ecr.py

@@ -1,12 +1,18 @@
+from collections import defaultdict
+
 import botocore
 from boto3 import Session
 
+from dbt_platform_helper.providers.aws.exceptions import AWSException
 from dbt_platform_helper.providers.aws.exceptions import ImageNotFoundException
+from dbt_platform_helper.providers.aws.exceptions import MultipleImagesFoundException
 from dbt_platform_helper.providers.aws.exceptions import RepositoryNotFoundException
 from dbt_platform_helper.providers.io import ClickIOProvider
-from dbt_platform_helper.utils.application import Application
 from dbt_platform_helper.utils.aws import get_aws_session_or_abort
 
+NOT_A_UNIQUE_TAG_INFO = 'INFO: The tag "{image_ref}" is not a unique, commit-specific tag. Deploying the corresponding commit tag "{commit_tag}" instead.'
+NO_ASSOCIATED_COMMIT_TAG_WARNING = 'WARNING: The AWS ECR image "{image_ref}" has no associated commit tag so deploying "{image_ref}". Note this could result in images with unintended or incompatible changes being deployed in new ECS Tasks for your service.'
+
 
 class ECRProvider:
     def __init__(self, session: Session = None, click_io: ClickIOProvider = ClickIOProvider()):
@@ -19,49 +25,68 @@ class ECRProvider:
             out.extend([repo["repositoryName"] for repo in page.get("repositories", {})])
         return out
 
-    def get_image_details(
-        self, application: Application, codebase: str, image_ref: str
-    ) -> list[dict]:
-        """Check if image exists in AWS ECR, and return a list of dictionaries
-        containing image metadata."""
+    def get_commit_tag_for_reference(self, application_name: str, codebase: str, image_ref: str):
+        repository = f"{application_name}/{codebase}"
+        next_page_token = None
+        tag_map = {}
+        digest_map = defaultdict(dict)
 
-        repository = f"{application.name}/{codebase}"
+        while True:
+            image_list = self._get_ecr_images(repository, image_ref, next_page_token)
+            next_page_token = image_list.get("nextToken")
 
-        try:
-            image_info = self._get_client().describe_images(
-                repositoryName=repository,
-                imageIds=[{"imageTag": image_ref}],
-            )
+            for image in image_list["imageIds"]:
+                digest, tag = image["imageDigest"], image["imageTag"]
+                digest_map[digest][tag.split("-")[0]] = tag
+                tag_map[tag] = digest
 
-            self._check_image_details_exists(image_info, image_ref)
+            if not next_page_token:
+                break
 
-            return image_info.get("imageDetails")
-        except botocore.exceptions.ClientError as e:
-            if e.response["Error"]["Code"] == "ImageNotFoundException":
+        if image_ref.startswith("commit-"):
+            if image_ref in tag_map:
+                return image_ref
+            else:
+                candidates = [
+                    tag
+                    for tag in tag_map.keys()
+                    if image_ref.startswith(tag) or tag.startswith(image_ref)
+                ]
+                if not candidates:
+                    raise ImageNotFoundException(image_ref)
+                if len(candidates) > 1:
+                    raise MultipleImagesFoundException(image_ref, candidates)
+                return candidates[0]
+        else:
+            digest = tag_map.get(image_ref)
+            if not digest:
                 raise ImageNotFoundException(image_ref)
-            if e.response["Error"]["Code"] == "RepositoryNotFoundException":
-                raise RepositoryNotFoundException(repository)
 
-    def find_commit_tag(self, image_details: list[dict], image_ref: str) -> str:
-        """Loop through imageTags list to query for an image tag starting with
-        'commit-', and return that value if found."""
+            commit_tag = digest_map.get(digest, dict()).get("commit")
 
-        if image_ref.startswith("commit-"):
-            return image_ref
-
-        if image_details:
-            for image in image_details:
-                image_tags = image.get("imageTags", {})
-                for tag in image_tags:
-                    if tag.startswith("commit-"):
-                        self.click_io.info(
-                            f'INFO: The tag "{image_ref}" is not a unique, commit-specific tag. Deploying the corresponding commit tag "{tag}" instead.'
-                        )
-                        return tag
-        self.click_io.warn(
-            f'WARNING: The AWS ECR image "{image_ref}" has no associated commit tag so deploying "{image_ref}". Note this could result in images with unintended or incompatible changes being deployed if new ECS Tasks for your service.'
-        )
-        return image_ref
+            if commit_tag:
+                self.click_io.info(
+                    NOT_A_UNIQUE_TAG_INFO.format(image_ref=image_ref, commit_tag=commit_tag)
+                )
+                return commit_tag
+            else:
+                self.click_io.warn(NO_ASSOCIATED_COMMIT_TAG_WARNING.format(image_ref=image_ref))
+                return image_ref
+
+    def _get_ecr_images(self, repository, image_ref, next_page_token):
+        params = {"repositoryName": repository, "filter": {"tagStatus": "TAGGED"}}
+        if next_page_token:
+            params["nextToken"] = next_page_token
+        try:
+            image_list = self._get_client().list_images(**params)
+            return image_list
+        except botocore.exceptions.ClientError as e:
+            if e.response["Error"]["Code"] == "RepositoryNotFoundException":
+                raise RepositoryNotFoundException(repository)
+            else:
+                raise AWSException(
+                    f"Unexpected error for repo '{repository}' and image reference '{image_ref}': {e}"
+                )
 
     @staticmethod
     def _check_image_details_exists(image_info: dict, image_ref: str):

dbt_platform_helper/providers/ecs.py

@@ -1,9 +1,29 @@
 import random
 import string
-import time
+import subprocess
 from typing import List
 
 from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.platform_exception import ValidationException
+from dbt_platform_helper.providers.vpc import Vpc
+from dbt_platform_helper.utilities.decorators import retry
+from dbt_platform_helper.utilities.decorators import wait_until
+
+
+class ECSException(PlatformException):
+    pass
+
+
+class ECSAgentNotRunningException(ECSException):
+    def __init__(self):
+        super().__init__("""ECS exec agent never reached "RUNNING" status""")
+
+
+class NoClusterException(ECSException):
+    def __init__(self, application_name: str, environment: str):
+        super().__init__(
+            f"""No ECS cluster found for "{application_name}" in "{environment}" environment."""
+        )
 
 
 class ECS:
@@ -13,7 +33,49 @@ class ECS:
         self.application_name = application_name
         self.env = env
 
-    def get_cluster_arn(self) -> str:
+    def start_ecs_task(
+        self,
+        cluster_name: str,
+        container_name: str,
+        task_def_arn: str,
+        vpc_config: Vpc,
+        env_vars: List[dict] = None,
+    ):
+        container_override = {"name": container_name}
+        if env_vars:
+            container_override["environment"] = env_vars
+
+        response = self.ecs_client.run_task(
+            taskDefinition=task_def_arn,
+            cluster=cluster_name,
+            capacityProviderStrategy=[
+                {"capacityProvider": "FARGATE", "weight": 1, "base": 0},
+            ],
+            enableExecuteCommand=True,
+            networkConfiguration={
+                "awsvpcConfiguration": {
+                    "subnets": vpc_config.public_subnets,
+                    "securityGroups": vpc_config.security_groups,
+                    "assignPublicIp": "ENABLED",
+                }
+            },
+            overrides={"containerOverrides": [container_override]},
+        )
+
+        return response.get("tasks", [{}])[0].get("taskArn")
+
+    def get_cluster_arn_by_name(self, cluster_name: str) -> str:
+        clusters = self.ecs_client.describe_clusters(
+            clusters=[
+                cluster_name,
+            ],
+        )["clusters"]
+        if len(clusters) == 1 and "clusterArn" in clusters[0]:
+            return clusters[0]["clusterArn"]
+
+        raise NoClusterException(self.application_name, self.env)
+
+    def get_cluster_arn_by_copilot_tag(self) -> str:
         """Returns the ARN of the ECS cluster for the given application and
         environment."""
         for cluster_arn in self.ecs_client.list_clusters()["clusterArns"]:
@@ -45,12 +107,12 @@ class ECS:
             random_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=12))
             return f"conduit-{self.application_name}-{self.env}-{addon_name}-{random_id}"
 
-    def get_ecs_task_arns(self, cluster_arn: str, task_name: str):
+    def get_ecs_task_arns(self, cluster_arn: str, task_def_family: str):
         """Gets the ECS task ARNs for a given task name and cluster ARN."""
         tasks = self.ecs_client.list_tasks(
             cluster=cluster_arn,
             desiredStatus="RUNNING",
-            family=f"copilot-{task_name}",
+            family=task_def_family,
         )
 
         if not tasks["taskArns"]:
@@ -58,45 +120,55 @@ class ECS:
 
         return tasks["taskArns"]
 
-    def ecs_exec_is_available(self, cluster_arn: str, task_arns: List[str]):
+    @retry()
+    def exec_task(self, cluster_arn: str, task_arn: str, subprocess_call=subprocess.call):
+        result = subprocess_call(
+            f"aws ecs execute-command --cluster {cluster_arn} "
+            f"--task {task_arn} "
+            f"--interactive --command bash ",
+            shell=True,
+        )
+        if result != 0:
+            raise PlatformException("Failed to exec into ECS task.")
+        return result
+
+    @wait_until(
+        max_attempts=25,
+        exceptions_to_catch=(ECSException,),
+        message_on_false="ECS Agent Not running",
+    )
+    def ecs_exec_is_available(self, cluster_arn: str, task_arns: List[str]) -> bool:
         """
         Checks if the ExecuteCommandAgent is running on the specified ECS task.
 
         Waits for up to 25 attempts, then raises ECSAgentNotRunning if still not
         running.
         """
-        current_attempts = 0
-        execute_command_agent_status = ""
-
-        while execute_command_agent_status != "RUNNING" and current_attempts < 25:
-            current_attempts += 1
-
-            task_details = self.ecs_client.describe_tasks(cluster=cluster_arn, tasks=task_arns)
-
-            managed_agents = task_details["tasks"][0]["containers"][0]["managedAgents"]
-            execute_command_agent_status = [
-                agent["lastStatus"]
-                for agent in managed_agents
-                if agent["name"] == "ExecuteCommandAgent"
-            ][0]
-            if execute_command_agent_status != "RUNNING":
-                time.sleep(1)
-
-        if execute_command_agent_status != "RUNNING":
-            raise ECSAgentNotRunningException
-
-
-class ECSException(PlatformException):
-    pass
-
-
-class ECSAgentNotRunningException(ECSException):
-    def __init__(self):
-        super().__init__("""ECS exec agent never reached "RUNNING" status""")
-
-
-class NoClusterException(ECSException):
-    def __init__(self, application_name: str, environment: str):
-        super().__init__(
-            f"""No ECS cluster found for "{application_name}" in "{environment}" environment."""
-        )
+        if not task_arns:
+            raise ValidationException("No task ARNs provided")
+        task_details = self.ecs_client.describe_tasks(cluster=cluster_arn, tasks=task_arns)
+
+        if not task_details["tasks"]:
+            raise ECSException("No ECS tasks returned.")
+        container_details = task_details["tasks"][0]["containers"][0]
+        if container_details.get("managedAgents", None):
+            managed_agents = container_details["managedAgents"]
+        else:
+            raise ECSException("No managed agent on ecs task.")
+
+        execute_command_agent = [
+            agent for agent in managed_agents if agent["name"] == "ExecuteCommandAgent"
+        ]
+        if not execute_command_agent:
+            raise ECSException("No ExecuteCommandAgent on ecs task.")
+        return execute_command_agent[0]["lastStatus"] == "RUNNING"
+
+    @wait_until(
+        max_attempts=20,
+        message_on_false="ECS task did not register in time",
+    )
+    def wait_for_task_to_register(self, cluster_arn: str, task_family: str) -> list[str]:
+        task_arns = self.get_ecs_task_arns(cluster_arn, task_family)
+        if task_arns:
+            return task_arns
+        return False

dbt_platform_helper/providers/io.py

@@ -1,14 +1,19 @@
+import os
+
 import click
 
 from dbt_platform_helper.platform_exception import PlatformException
 
+DEBUG = os.environ.get("DEBUG", False)
+
 
 class ClickIOProvider:
     def warn(self, message: str):
         click.secho(message, fg="magenta")
 
     def debug(self, message: str):
-        click.secho(message, fg="green")
+        if DEBUG == "True":
+            click.secho(message, fg="green")
 
     def error(self, message: str):
         click.secho(f"Error: {message}", fg="red")

dbt_platform_helper/providers/terraform_manifest.py

@@ -140,7 +140,12 @@ class TerraformManifestProvider:
     def _add_extensions_module(terraform: dict, platform_helper_version: str, env: str):
         source = f"git::https://github.com/uktrade/platform-tools.git//terraform/extensions?depth=1&ref={platform_helper_version}"
         terraform["module"] = {
-            "extensions": {"source": source, "args": "${local.args}", "environment": env}
+            "extensions": {
+                "source": source,
+                "args": "${local.args}",
+                "environment": env,
+                "repos": "${local.codebase_pipeline_repos != null ? (distinct(values(local.codebase_pipeline_repos))) : null}",
+            }
         }
 
     @staticmethod
@@ -163,6 +168,7 @@ class TerraformManifestProvider:
                 "services": '${local.config["extensions"]}',
                 "env_config": "${local.env_config}",
             },
+            "codebase_pipeline_repos": '${try({for k, v in local.config["codebase_pipelines"]: k => v.repository}, null)}',
         }
 
     @staticmethod

dbt_platform_helper/providers/version.py

@@ -10,9 +10,9 @@ from requests import Session
 from requests.adapters import HTTPAdapter
 from urllib3.util import Retry
 
+from dbt_platform_helper.entities.semantic_version import SemanticVersion
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.io import ClickIOProvider
-from dbt_platform_helper.providers.semantic_version import SemanticVersion
 
 
 def set_up_retry():

dbt_platform_helper/providers/version_status.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
+from dbt_platform_helper.entities.semantic_version import SemanticVersion
 from dbt_platform_helper.platform_exception import PlatformException
-from dbt_platform_helper.providers.semantic_version import SemanticVersion
 
 
 class UnsupportedVersionException(PlatformException):

dbt_platform_helper/providers/vpc.py

@@ -77,8 +77,8 @@ class VpcProvider:
         return vpc_id
 
     def _get_security_groups(self, app: str, env: str, vpc_id: str) -> list:
-
         vpc_filter = {"Name": "vpc-id", "Values": [vpc_id]}
+        # TODO Handle terraformed environment SG https://uktrade.atlassian.net/browse/DBTP-2074
         tag_filter = {"Name": f"tag:Name", "Values": [f"copilot-{app}-{env}-env"]}
         response = self.ec2_client.describe_security_groups(Filters=[vpc_filter, tag_filter])
 

dbt_platform_helper/utilities/decorators.py

@@ -0,0 +1,103 @@
+import functools
+import time
+from typing import Callable
+from typing import Optional
+
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.io import ClickIOProvider
+
+SECONDS_BEFORE_RETRY = 3
+RETRY_MAX_ATTEMPTS = 3
+
+
+class RetryException(PlatformException):
+
+    def __init__(
+        self, function_name: str, max_attempts: int, original_exception: Optional[Exception] = None
+    ):
+        message = f"Function: {function_name} failed after {max_attempts} attempts"
+        self.original_exception = original_exception
+        if original_exception:
+            message += f": \n{str(original_exception)}"
+        super().__init__(message)
+
+
+def retry(
+    exceptions_to_catch: tuple = (Exception,),
+    max_attempts: int = RETRY_MAX_ATTEMPTS,
+    delay: float = SECONDS_BEFORE_RETRY,
+    raise_custom_exception: bool = True,
+    custom_exception: type = RetryException,
+    io: ClickIOProvider = ClickIOProvider(),
+):
+    def decorator(func):
+        func.__wrapped_by__ = "retry"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            last_exception = None
+            for attempt in range(max_attempts):
+                try:
+                    return func(*args, **kwargs)
+                except exceptions_to_catch as e:
+                    last_exception = e
+                    io.debug(
+                        f"Attempt {attempt+1}/{max_attempts} for {func.__name__} failed with exception {str(last_exception)}"
+                    )
+                    if attempt < max_attempts - 1:
+                        time.sleep(delay)
+            if raise_custom_exception:
+                raise custom_exception(func.__name__, max_attempts, last_exception)
+            raise last_exception
+
+        return wrapper
+
+    return decorator
+
+
+def wait_until(
+    exceptions_to_catch: tuple = (PlatformException,),
+    max_attempts: int = RETRY_MAX_ATTEMPTS,
+    delay: float = SECONDS_BEFORE_RETRY,
+    raise_custom_exception: bool = True,
+    custom_exception=RetryException,
+    message_on_false="Condition not met",
+    io: ClickIOProvider = ClickIOProvider(),
+):
+    """Wrap a function which returns a boolean."""
+
+    def decorator(func: Callable[..., bool]):
+        func.__wrapped_by__ = "wait_until"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            last_exception = None
+            for attempt in range(max_attempts):
+                try:
+                    result = func(*args, **kwargs)
+                    if result:
+                        return result
+                    io.debug(
+                        f"Attempt {attempt+1}/{max_attempts} for {func.__name__} returned falsy"
+                    )
+                except exceptions_to_catch as e:
+                    last_exception = e
+                    io.debug(
+                        f"Attempt {attempt+1}/{max_attempts} for {func.__name__} failed with exception {str(last_exception)}"
+                    )
+
+                if attempt < max_attempts - 1:
+                    time.sleep(delay)
+
+            if not last_exception:  # If func returns false set last_exception
+                last_exception = PlatformException(message_on_false)
+            if (
+                not raise_custom_exception
+            ):  # Raise last_exception when you don't want custom exception
+                raise last_exception
+            else:
+                raise custom_exception(func.__name__, max_attempts, last_exception)
+
+        return wrapper
+
+    return decorator

dbt_platform_helper/utils/validation.py

@@ -1,7 +1,7 @@
 from schema import SchemaError
 
+from dbt_platform_helper.entities.platform_config_schema import PlatformConfigSchema
 from dbt_platform_helper.providers.config_validator import ConfigValidator
-from dbt_platform_helper.providers.platform_config_schema import PlatformConfigSchema
 
 
 def validate_addons(addons: dict):

{dbt_platform_helper-15.0.0.dist-info → dbt_platform_helper-15.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dbt-platform-helper
-Version: 15.0.0
+Version: 15.2.0
 Summary: Set of tools to help transfer applications/services from GOV.UK PaaS to DBT PaaS augmenting AWS Copilot.
 License: MIT
 Author: Department for Business and Trade Platform Team

{dbt_platform_helper-15.0.0.dist-info → dbt_platform_helper-15.2.0.dist-info}/RECORD

@@ -18,9 +18,9 @@ dbt_platform_helper/commands/version.py,sha256=2GltWeeN7cqhVj9FhYWSbXSQSyNILHVNO
 dbt_platform_helper/constants.py,sha256=Ao2uvVRcxRN5SXqvW6Jq2srd7LuyGz1jPy4fg2N6XSk,1153
 dbt_platform_helper/default-extensions.yml,sha256=SU1ZitskbuEBpvE7efc3s56eAUF11j70brhj_XrNMMo,493
 dbt_platform_helper/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dbt_platform_helper/domain/codebase.py,sha256=9BTs7PNYaBRqthv5bAR6_dtiwmAQ1CIZjt3jN21aQv8,12228
-dbt_platform_helper/domain/conduit.py,sha256=5C5GnF5jssJ1rFFCY6qaKgvLjYUkyytRJE4tHlanYa0,4370
-dbt_platform_helper/domain/config.py,sha256=NtWAPkopwclKajYzkqbTOQtaMAy2KMU3hc77biBC2eM,13804
+dbt_platform_helper/domain/codebase.py,sha256=2hJoBiDB2ciOudT_YUR44XV0ZQPWUJld_UIuds4XOt8,12481
+dbt_platform_helper/domain/conduit.py,sha256=0aX5rhynkkJj8rJUwfyLENyCwlAI67_Vkky1lOEl6rw,12496
+dbt_platform_helper/domain/config.py,sha256=Iyf-lV4YDD6BHH-RRaTvp-7qPS8BYeHM_SkSfeU7si4,13802
 dbt_platform_helper/domain/copilot.py,sha256=9L4h-WFwgRU8AMjf14PlDqwLqOpIRinkuPvhe-8Uk3c,15034
 dbt_platform_helper/domain/copilot_environment.py,sha256=fL3XJCOfO0BJRCrCoBPFCcshrQoX1FeSYNTziOEaH4A,9093
 dbt_platform_helper/domain/database_copy.py,sha256=AedcBTfKDod0OlMqVP6zb9c_9VIc3vqro0oUUhh7nwc,9497
@@ -28,40 +28,40 @@ dbt_platform_helper/domain/maintenance_page.py,sha256=0_dgM5uZvjVNBKcqScspjutinM
 dbt_platform_helper/domain/notify.py,sha256=_BWj5znDWtrSdJ5xzDBgnao4ukliBA5wiUZGobIDyiI,1894
 dbt_platform_helper/domain/pipelines.py,sha256=BUoXlV4pIKSw3Ry6oVMzd0mBU6tfl_tvqp-1zxHrQdk,6552
 dbt_platform_helper/domain/terraform_environment.py,sha256=kPfA44KCNnF_7ihQPuxaShLjEnVShrbruLwr5xoCeRc,1825
-dbt_platform_helper/domain/versioning.py,sha256=kqx7P4iSjQxXJ58cTCdxTcTcJ-kYX7G28jMMlp_Zvc8,5497
+dbt_platform_helper/domain/versioning.py,sha256=pIL8VPAJHqX5kJBp3QIxII5vmUo4aIYW_U9u_KxUJd0,5494
+dbt_platform_helper/entities/platform_config_schema.py,sha256=ADkEP5PEjZswBKuPvpi1QHW_dXiC-CIAx730c11Uio0,27544
+dbt_platform_helper/entities/semantic_version.py,sha256=VgQ6V6OgSaleuVmMB8Kl_yLoakXl2auapJTDbK00mfc,2679
 dbt_platform_helper/jinja2_tags.py,sha256=hKG6RS3zlxJHQ-Op9r2U2-MhWp4s3lZir4Ihe24ApJ0,540
-dbt_platform_helper/platform_exception.py,sha256=bheZV9lqGvrCVTNT92349dVntNDEDWTEwciZgC83WzE,187
+dbt_platform_helper/platform_exception.py,sha256=HGfCYRD20REsynqMKmyZndTfdkMd5dLSIEB2qGGCeP8,244
 dbt_platform_helper/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbt_platform_helper/providers/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dbt_platform_helper/providers/aws/exceptions.py,sha256=TOaUdTySNGZ9fU3kofgIj6upMmd4IT2f0rpbn8YR6fs,1742
+dbt_platform_helper/providers/aws/exceptions.py,sha256=7zrbzGuZhZypmT7LB4pK7TrYD4kn5H0L_lgx07o2VPg,2332
 dbt_platform_helper/providers/aws/interfaces.py,sha256=0JFggcUTJ8zERdxNVVpIiKvaaZeT2c-VECDG--MOi8E,285
 dbt_platform_helper/providers/aws/opensearch.py,sha256=Qne2SoPllmacVSc7AxtjBlEbSBsRMbR_ySEkEymSF9k,581
 dbt_platform_helper/providers/aws/redis.py,sha256=i3Kb00_BdqssjQg1wgZ-8GRXcEWQiORWnIEq6qkAXjQ,551
 dbt_platform_helper/providers/aws/sso_auth.py,sha256=1cE9gVu0XZoE3Nycs1anShistRU_CZCOGMFzFpaAq0w,2275
 dbt_platform_helper/providers/cache.py,sha256=1hEwp0y9WYbEfgsp-RU9MyzIgCt1-4BxApgd_0uVweE,3615
 dbt_platform_helper/providers/cloudformation.py,sha256=syMH6xc-ALRbsYQvlw9RcjX7c1MufFzwEdEzp_ucWig,5359
-dbt_platform_helper/providers/config.py,sha256=7Mq0i-cg_YeAbWOlnDI0GGpszDNPRvFZiX49ETR3YDE,9863
+dbt_platform_helper/providers/config.py,sha256=8eK6txDTTF3s3iy7WxKszlaE33pHVhbJ55UDUJ9_nYw,9861
 dbt_platform_helper/providers/config_validator.py,sha256=uF1GB-fl0ZuXVCtLNANgnY22UbiWZniBg1PiXgzGzuU,9923
-dbt_platform_helper/providers/copilot.py,sha256=eruF_ZWWtrJFNQVuzXRMRfqOWGCXpvR7yu50olU4Nk8,5362
-dbt_platform_helper/providers/ecr.py,sha256=siCGTEXR8Jd_pemPfKI3_U5P3Ix6dPrhWsg94EQiZzA,3266
-dbt_platform_helper/providers/ecs.py,sha256=XlQHYhZiLGrqR-1ZWMagGH2R2Hy7mCP6676eZL3YbNQ,3842
+dbt_platform_helper/providers/copilot.py,sha256=voFVGhvtOElulx6Cgd1KQGkybrg8v4oGkJTr_xRpF18,5582
+dbt_platform_helper/providers/ecr.py,sha256=eYXSY1-pFN6F3Es1WSZgv3dmvX2oD-baqhHDO-QzgVg,4382
+dbt_platform_helper/providers/ecs.py,sha256=4XRpOgcl7KFiTp9lhNrp4Lvmje0ZFYuUh9Z_eEqhyhA,6538
 dbt_platform_helper/providers/files.py,sha256=cJdOV6Eupi-COmGUMxZMF10BZnMi3MCCipTVUnE_NPA,857
-dbt_platform_helper/providers/io.py,sha256=tU0jK8krKvBmdGM-sQXpFEqcUxORjFKFIdMNIe3TKB0,1376
+dbt_platform_helper/providers/io.py,sha256=5C7XUxy3XNqSWgxryr4Uy0l4J9np_lryGskqE0TRpmQ,1459
 dbt_platform_helper/providers/kms.py,sha256=JR2EU3icXePoJCtr7QnqDPj1wWbyn5Uf9CRFq3_4lRs,647
 dbt_platform_helper/providers/load_balancers.py,sha256=G-gqhthaO6ZmpKq6zAqnY1AUtc5YjnI99sQzpeaM0ec,10644
 dbt_platform_helper/providers/parameter_store.py,sha256=klxDhcQ65Yc2KAc4Gf5P0vhpZOW7_vZalAVb-LLAA4s,1568
-dbt_platform_helper/providers/platform_config_schema.py,sha256=ADkEP5PEjZswBKuPvpi1QHW_dXiC-CIAx730c11Uio0,27544
 dbt_platform_helper/providers/schema_migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbt_platform_helper/providers/schema_migrations/schema_v0_to_v1_migration.py,sha256=dplbvEAc8l8F4dEAy3JwLP1Phjkt4QVuQYNX_EKe_Ls,2036
 dbt_platform_helper/providers/schema_migrator.py,sha256=qk14k3hMz1av9VrxHyJw2OKJLQnCBv_ugOoxZr3tFXQ,2854
 dbt_platform_helper/providers/secrets.py,sha256=mOTIrcRRxxV2tS40U8onAjWekfPS3NzCvvyCMjr_yrU,5327
-dbt_platform_helper/providers/semantic_version.py,sha256=VgQ6V6OgSaleuVmMB8Kl_yLoakXl2auapJTDbK00mfc,2679
 dbt_platform_helper/providers/slack_channel_notifier.py,sha256=G8etEcaBQSNHg8BnyC5UPv6l3vUB14cYWjcaAQksaEk,2135
-dbt_platform_helper/providers/terraform_manifest.py,sha256=otqVh_0KCqP35bZstTzd-TEEe0BYvEWmVn_quYumiNs,9345
+dbt_platform_helper/providers/terraform_manifest.py,sha256=gfluve8mcHSkZqq4nNhazte48I7LFbJoQAVBMJBnNk4,9660
 dbt_platform_helper/providers/validation.py,sha256=i2g-Mrd4hy_fGIfGa6ZQy4vTJ40OM44Fe_XpEifGWxs,126
-dbt_platform_helper/providers/version.py,sha256=pU1dCXo05Jm0Np6u6HiFFfpHEHNtWyU9fSXDZMqmRpU,4252
-dbt_platform_helper/providers/version_status.py,sha256=-y9-kNvXGHVT6IbMOVu30vNyPOEShH-rAVMFHlJek1U,930
-dbt_platform_helper/providers/vpc.py,sha256=EIjjD71K1Ry3V1jyaAkAjZwlwu_FSTn-AS7kiJFiipA,2953
+dbt_platform_helper/providers/version.py,sha256=QNGrV5nyJi0JysXowYUU4OrXGDn27WmFezlV8benpdY,4251
+dbt_platform_helper/providers/version_status.py,sha256=qafnhZrEc9k1cvXJpvJhkGj6WtkzcsoQhqS_Y6JXy48,929
+dbt_platform_helper/providers/vpc.py,sha256=V8kXXzy-JuRpuzZhI9xyfcNky-eD42K0v_uM2WejLoo,3048
 dbt_platform_helper/providers/yaml_file.py,sha256=LZ8eCPDQRr1wlck13My5hQa0eE2OVhSomm-pOIuZ9h0,2881
 dbt_platform_helper/templates/.copilot/config.yml,sha256=J_bA9sCtBdCPBRImpCBRnYvhQd4vpLYIXIU-lq9vbkA,158
 dbt_platform_helper/templates/.copilot/image_build_run.sh,sha256=adYucYXEB-kAgZNjTQo0T6EIAY8sh_xCEvVhWKKQ8mw,164
@@ -87,6 +87,7 @@ dbt_platform_helper/templates/svc/maintenance_pages/default.html,sha256=OTZ-qwwS
 dbt_platform_helper/templates/svc/maintenance_pages/dmas-migration.html,sha256=qvI6tHuI0UQbMBCuvPgK1a_zLANB6w7KVo9N5d8r-i0,829
 dbt_platform_helper/templates/svc/maintenance_pages/migration.html,sha256=GiQsOiuaMFb7jG5_wU3V7BMcByHBl9fOBgrNf8quYlw,783
 dbt_platform_helper/templates/svc/overrides/cfn.patches.yml,sha256=W7-d017akuUq9kda64DQxazavcRcCPDjaAik6t1EZqM,742
+dbt_platform_helper/utilities/decorators.py,sha256=rS6ohsuo0bc6fkZP98Qwaeh0c_v2MDqn9hCvqfoz2w8,3548
 dbt_platform_helper/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbt_platform_helper/utils/application.py,sha256=d7Tg5odZMy9e3o4R0mmU19hrxJuIfS_ATDH4hY8zJvk,5480
 dbt_platform_helper/utils/arn_parser.py,sha256=BaXzIxSOLdFmP_IfAxRq-0j-0Re1iCN7L4j2Zi5-CRQ,1304
@@ -95,10 +96,10 @@ dbt_platform_helper/utils/click.py,sha256=Fx4y4bbve1zypvog_sgK7tJtCocmzheoEFLBRv
 dbt_platform_helper/utils/git.py,sha256=9jyLhv37KKE6r-_hb3zvjhTbluA81kdrOdNeG6MB-_M,384
 dbt_platform_helper/utils/messages.py,sha256=nWA7BWLb7ND0WH5TejDN4OQUJSKYBxU4tyCzteCrfT0,142
 dbt_platform_helper/utils/template.py,sha256=g-Db-0I6a6diOHkgK1nYA0IxJSO4TRrjqOvlyeOR32o,950
-dbt_platform_helper/utils/validation.py,sha256=coN7WsKW_nPGW9EU23AInBkAuvUl1NfQvc2bjVtgs14,1188
+dbt_platform_helper/utils/validation.py,sha256=W5jKC2zp5Q7cJ0PT57GB-s9FkJXrNt1jmWojXRFymcY,1187
 platform_helper.py,sha256=_YNNGtMkH5BcpC_mQQYJrmlf2mt7lkxTYeH7ZgflPoA,1925
-dbt_platform_helper-15.0.0.dist-info/LICENSE,sha256=dP79lN73--7LMApnankTGLqDbImXg8iYFqWgnExGkGk,1090
-dbt_platform_helper-15.0.0.dist-info/METADATA,sha256=t2pSFArbvOvniLssLuR9bq9ATpt_9TzVs8et5x_6xX8,3293
-dbt_platform_helper-15.0.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-dbt_platform_helper-15.0.0.dist-info/entry_points.txt,sha256=QhbY8F434A-onsg0-FsdMd2U6HKh6Q7yCFFZrGUh5-M,67
-dbt_platform_helper-15.0.0.dist-info/RECORD,,
+dbt_platform_helper-15.2.0.dist-info/LICENSE,sha256=dP79lN73--7LMApnankTGLqDbImXg8iYFqWgnExGkGk,1090
+dbt_platform_helper-15.2.0.dist-info/METADATA,sha256=ypOBRkc3nhUh287vmFdYew3x44PGZ1VC57TKjd5e3Ds,3293
+dbt_platform_helper-15.2.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+dbt_platform_helper-15.2.0.dist-info/entry_points.txt,sha256=QhbY8F434A-onsg0-FsdMd2U6HKh6Q7yCFFZrGUh5-M,67
+dbt_platform_helper-15.2.0.dist-info/RECORD,,

{dbt_platform_helper-15.0.0.dist-info → dbt_platform_helper-15.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any