dbt-platform-helper 15.10.0__py3-none-any.whl → 15.12.0__py3-none-any.whl

dbt_platform_helper/providers/ecs.py

@@ -1,7 +1,10 @@
 import random
 import string
 import subprocess
-from typing import List
+from typing import Any
+from typing import Optional
+
+from botocore.exceptions import ClientError
 
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.platform_exception import ValidationException
@@ -39,7 +42,7 @@ class ECS:
         container_name: str,
         task_def_arn: str,
         vpc_config: Vpc,
-        env_vars: List[dict] = None,
+        env_vars: list[dict] = None,
     ):
         container_override = {"name": container_name}
         if env_vars:
@@ -107,13 +110,31 @@ 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_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=task_def_family,
-        )
+    def get_ecs_task_arns(
+        self,
+        cluster: str,
+        max_results: int = 100,
+        desired_status: str = "RUNNING",
+        service_name: Optional[str] = None,
+        started_by: Optional[str] = None,
+        task_def_family: Optional[str] = None,
+    ) -> list[str]:
+        """Returns the ECS task ARNs based on the parameters provided."""
+
+        params = {
+            "cluster": cluster,
+            "maxResults": max_results,
+            "desiredStatus": desired_status,
+        }
+
+        if service_name:
+            params["serviceName"] = service_name
+        if started_by:
+            params["startedBy"] = started_by
+        if task_def_family:
+            params["family"] = task_def_family
+
+        tasks = self.ecs_client.list_tasks(**params)
 
         if not tasks["taskArns"]:
             return []
@@ -137,7 +158,7 @@ class ECS:
         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:
+    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.
 
@@ -168,7 +189,79 @@ class ECS:
         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)
+        task_arns = self.get_ecs_task_arns(cluster=cluster_arn, task_def_family=task_family)
         if task_arns:
             return task_arns
         return False
+
+    def get_service_rollout_state(
+        self, cluster_name: str, service_name: str, start_time: float
+    ) -> tuple[Optional[str], Optional[str]]:
+        """
+        Returns status & statusReason for the deployment of an ECS service.
+
+        statusReason can be:
+            PENDING | SUCCESSFUL | STOPPED | STOP_REQUESTED |
+            IN_PROGRESS | ROLLBACK_REQUESTED | ROLLBACK_IN_PROGRESS |
+            ROLLBACK_SUCCESSFUL | ROLLBACK_FAILED
+        """
+        resp = self.ecs_client.list_service_deployments(
+            cluster=cluster_name, service=service_name, createdAt={"after": start_time - 180}
+        )
+        deployments = resp.get("serviceDeployments", [])
+
+        if not deployments:
+            return None, f"No deployments found for '{service_name}'"
+
+        return deployments[0].get("status"), deployments[0].get("statusReason")
+
+    def get_container_names_from_ecs_tasks(
+        self, cluster_name: str, task_ids: list[str]
+    ) -> list[str]:
+        """Retrieve container names from each ECS task provided."""
+
+        response = self.ecs_client.describe_tasks(cluster=cluster_name, tasks=task_ids)
+
+        names = []
+        for task in response.get("tasks", []):
+            for container in task.get("containers", []):
+                if container["name"] not in names:
+                    names.append(container["name"])
+        return names
+
+    def register_task_definition(
+        self,
+        service: str,
+        task_definition: dict,
+        image_tag: Optional[str] = None,
+    ) -> str:
+        """Register a new task definition revision using provided model and
+        containerDefinitions."""
+
+        if image_tag:
+            for container in task_definition["containerDefinitions"]:
+                if container["name"] == service:
+                    image_uri = container["image"].rsplit(":", 1)[0]
+                    container["image"] = f"{image_uri}:{image_tag}"
+                    break
+
+        try:
+            task_definition_response = self.ecs_client.register_task_definition(**task_definition)
+            return task_definition_response["taskDefinition"]["taskDefinitionArn"]
+        except ClientError as err:
+            raise PlatformException(f"Error registering task definition: {err}")
+
+    def update_service(
+        self, service: str, task_def_arn: str, environment: str, application: str
+    ) -> dict[str, Any]:
+        """Update an ECS service and return the response."""
+
+        try:
+            service_response = self.ecs_client.update_service(
+                cluster=f"{application}-{environment}-cluster",
+                service=f"{application}-{environment}-{service}",
+                taskDefinition=task_def_arn,
+            )
+            return service_response["service"]
+        except ClientError as err:
+            raise PlatformException(f"Error updating ECS service: {err}")

dbt_platform_helper/providers/load_balancers.py

@@ -1,7 +1,14 @@
+import json
+from typing import Dict
+from typing import List
+
 from boto3 import Session
 
+from dbt_platform_helper.constants import MANAGED_BY_PLATFORM_TERRAFORM
+from dbt_platform_helper.constants import ROUTED_TO_PLATFORM_MODES
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.parameter_store import ParameterStore
 from dbt_platform_helper.utils.aws import get_aws_session_or_abort
 
 
@@ -12,12 +19,24 @@ def normalise_to_cidr(ip: str):
     return f"{ip}/{SINGLE_IPV4_CIDR_PREFIX_LENGTH}"
 
 
+class ALBDataNormaliser:
+
+    @staticmethod
+    def tags_to_dict(tags: List[Dict[str, str]]) -> Dict[str, str]:
+        return {tag.get("Key", ""): tag.get("Value", "") for tag in tags}
+
+    @staticmethod
+    def conditions_to_dict(conditions: List[Dict[str, List[str]]]) -> Dict[str, List[str]]:
+        return {condition.get("Field", ""): condition.get("Values", "") for condition in conditions}
+
+
 class LoadBalancerProvider:
 
     def __init__(self, session: Session = None, io: ClickIOProvider = ClickIOProvider()):
         self.session = session
         self.evlb_client = self._get_client("elbv2")
         self.rg_tagging_client = self._get_client("resourcegroupstaggingapi")
+        self.parameter_store_provider = ParameterStore(self._get_client("ssm"))
         self.io = io
 
     def _get_client(self, client: str):
@@ -26,21 +45,44 @@ class LoadBalancerProvider:
         return self.session.client(client)
 
     def find_target_group(self, app: str, env: str, svc: str) -> str:
+
+        # TODO once copilot is gone this is no longer needed
+        try:
+            result = self.parameter_store_provider.get_ssm_parameter_by_name(
+                f"/platform/applications/{app}/environments/{env}"
+            )["Value"]
+            env_config = json.loads(result)
+            service_deployment_mode = env_config["service_deployment_mode"]
+        except Exception:
+            service_deployment_mode = "copilot"
+
+        if service_deployment_mode in ROUTED_TO_PLATFORM_MODES:
+            application_key = "application"
+            environment_key = "environment"
+            service_key = "service"
+        else:
+            application_key = "copilot-application"
+            environment_key = "copilot-environment"
+            service_key = "copilot-service"
         target_group_arn = None
 
         paginator = self.rg_tagging_client.get_paginator("get_resources")
         page_iterator = paginator.paginate(
             TagFilters=[
                 {
-                    "Key": "copilot-application",
+                    "Key": application_key,
                     "Values": [
                         app,
                     ],
-                    "Key": "copilot-environment",
+                },
+                {
+                    "Key": environment_key,
                     "Values": [
                         env,
                     ],
-                    "Key": "copilot-service",
+                },
+                {
+                    "Key": service_key,
                     "Values": [
                         svc,
                     ],
@@ -56,9 +98,9 @@ class LoadBalancerProvider:
                 tags = {tag["Key"]: tag["Value"] for tag in resource["Tags"]}
 
                 if (
-                    tags.get("copilot-service") == svc
-                    and tags.get("copilot-environment") == env
-                    and tags.get("copilot-application") == app
+                    tags.get(service_key) == svc
+                    and tags.get(environment_key) == env
+                    and tags.get(application_key) == app
                 ):
                     target_group_arn = resource["ResourceARN"]
 
@@ -69,6 +111,29 @@ class LoadBalancerProvider:
 
         return target_group_arn
 
+    def get_target_groups(self, target_group_arns: List[str]) -> List[dict]:
+        tgs = []
+        paginator = self.evlb_client.get_paginator("describe_target_groups")
+        page_iterator = paginator.paginate(TargetGroupArns=target_group_arns)
+        for page in page_iterator:
+            tgs.extend(page["TargetGroups"])
+
+        return tgs
+
+    def get_target_groups_with_tags(
+        self, target_group_arns: List[str], normalise: bool = True
+    ) -> List[dict]:
+        target_groups = self.get_target_groups(target_group_arns)
+
+        tags = self.get_resources_tag_descriptions(target_groups, "TargetGroupArn")
+
+        tgs_with_tags = self.merge_in_tags_by_resource_arn(target_groups, tags, "TargetGroupArn")
+
+        if normalise:
+            for tg in tgs_with_tags:
+                tg["Tags"] = ALBDataNormaliser.tags_to_dict(tg["Tags"])
+        return tgs_with_tags
+
     def get_https_certificate_for_listener(self, listener_arn: str, env: str):
         certificates = []
         paginator = self.evlb_client.get_paginator("describe_listener_certificates")
@@ -87,7 +152,7 @@ class LoadBalancerProvider:
         listener_arn = self.get_https_listener_for_application(app, env)
         return self.get_https_certificate_for_listener(listener_arn, env)
 
-    def get_listeners_for_load_balancer(self, load_balancer_arn):
+    def get_listeners_for_load_balancer(self, load_balancer_arn: str) -> List[dict]:
         listeners = []
         paginator = self.evlb_client.get_paginator("describe_listeners")
         page_iterator = paginator.paginate(LoadBalancerArn=load_balancer_arn)
@@ -98,6 +163,7 @@ class LoadBalancerProvider:
 
     def get_https_listener_for_application(self, app: str, env: str) -> str:
         load_balancer_arn = self.get_load_balancer_for_application(app, env)
+        self.io.debug(f"Load Balancer ARN: {load_balancer_arn}")
         listeners = self.get_listeners_for_load_balancer(load_balancer_arn)
 
         listener_arn = None
@@ -112,7 +178,7 @@ class LoadBalancerProvider:
 
         return listener_arn
 
-    def get_load_balancers(self):
+    def get_load_balancers(self) -> List[dict]:
         load_balancers = []
         paginator = self.evlb_client.get_paginator("describe_load_balancers")
         page_iterator = paginator.paginate()
@@ -133,7 +199,11 @@ class LoadBalancerProvider:
         for lb in tag_descriptions:
             tags = {t["Key"]: t["Value"] for t in lb["Tags"]}
             # TODO: DBTP-1967: copilot hangover, creates coupling to specific tags could update to check application and environment
-            if tags.get("copilot-application") == app and tags.get("copilot-environment") == env:
+            if (
+                tags.get("copilot-application") == app
+                and tags.get("copilot-environment") == env
+                and tags.get("managed-by", "") == MANAGED_BY_PLATFORM_TERRAFORM
+            ):
                 return lb["ResourceArn"]
 
         raise LoadBalancerNotFoundException(app, env)
@@ -173,7 +243,37 @@ class LoadBalancerProvider:
     def get_rules_tag_descriptions_by_listener_arn(self, listener_arn: str) -> list:
         rules = self.get_listener_rules_by_listener_arn(listener_arn)
 
-        return self.get_rules_tag_descriptions(rules)
+        return self.get_resources_tag_descriptions(rules)
+
+    def merge_in_tags_by_resource_arn(
+        self,
+        resources: List[dict],
+        tag_descriptions: List[dict],
+        resources_identifier: str = "RuleArn",
+    ):
+        tags_by_resource_arn = {
+            rule_tags.get("ResourceArn"): rule_tags for rule_tags in tag_descriptions if rule_tags
+        }
+        for resource in resources:
+            tags = tags_by_resource_arn[resource[resources_identifier]]
+            resource.update(tags)
+        return resources
+
+    def get_rules_with_tags_by_listener_arn(
+        self, listener_arn: str, normalise: bool = True
+    ) -> list:
+        rules = self.get_listener_rules_by_listener_arn(listener_arn)
+
+        tags = self.get_resources_tag_descriptions(rules)
+
+        rules_with_tags = self.merge_in_tags_by_resource_arn(rules, tags)
+
+        if normalise:
+            for rule in rules_with_tags:
+                rule["Conditions"] = ALBDataNormaliser.conditions_to_dict(rule["Conditions"])
+                rule["Tags"] = ALBDataNormaliser.tags_to_dict(rule["Tags"])
+
+        return rules_with_tags
 
     def get_listener_rules_by_listener_arn(self, listener_arn: str) -> list:
         rules = []
@@ -184,13 +284,15 @@ class LoadBalancerProvider:
 
         return rules
 
-    def get_rules_tag_descriptions(self, rules: list) -> list:
+    def get_resources_tag_descriptions(
+        self, resources: list, resource_identifier: str = "RuleArn"
+    ) -> list:
         tag_descriptions = []
         chunk_size = 20
 
-        for i in range(0, len(rules), chunk_size):
-            chunk = rules[i : i + chunk_size]
-            resource_arns = [r["RuleArn"] for r in chunk]
+        for i in range(0, len(resources), chunk_size):
+            chunk = resources[i : i + chunk_size]
+            resource_arns = [r[resource_identifier] for r in chunk]
             response = self.evlb_client.describe_tags(
                 ResourceArns=resource_arns
             )  # describe_tags cannot be paginated - 04/04/2025
@@ -305,6 +407,9 @@ class LoadBalancerProvider:
 
         return deleted_rules
 
+    def delete_listener_rule_by_resource_arn(self, resource_arn: str) -> list:
+        return self.evlb_client.delete_rule(RuleArn=resource_arn)
+
 
 class LoadBalancerException(PlatformException):
     pass

dbt_platform_helper/providers/logs.py

@@ -0,0 +1,57 @@
+import time
+
+import boto3
+from botocore.exceptions import ClientError
+
+from dbt_platform_helper.platform_exception import PlatformException
+
+
+class LogsProvider:
+
+    def __init__(self, client: boto3.client):
+        self.client = client
+
+    def check_log_streams_present(self, log_group: str, expected_log_streams: list[str]) -> bool:
+        """
+        Check whether the logs streams provided exist or not.
+
+        Retry for up to 5 minutes.
+        """
+
+        found_log_streams = set()
+        expected_log_streams = set(expected_log_streams)
+        timeout_seconds = 300
+        poll_interval_seconds = 2
+        deadline_seconds = time.monotonic() + timeout_seconds
+
+        while time.monotonic() < deadline_seconds:
+
+            remaining_log_streams = expected_log_streams - found_log_streams
+            if not remaining_log_streams:
+                return True
+
+            for log_stream in list(remaining_log_streams):
+                try:
+                    response = self.client.describe_log_streams(
+                        logGroupName=log_group, logStreamNamePrefix=log_stream, limit=1
+                    )
+                except ClientError as e:
+                    code = e.response.get("Error", {}).get("Code")
+                    if code == "ResourceNotFoundException":
+                        continue  # Log stream not there yet, keep going
+                    else:
+                        raise PlatformException(
+                            f"Failed to check if log stream '{log_stream}' exists due to an error {e}"
+                        )
+
+                for ls in response.get("logStreams", []):
+                    if ls.get("logStreamName") == log_stream:
+                        found_log_streams.add(log_stream)
+
+            if expected_log_streams - found_log_streams:
+                time.sleep(poll_interval_seconds)
+
+        missing_log_streams = expected_log_streams - found_log_streams
+        raise PlatformException(
+            f"Timed out waiting for the following log streams to create: {missing_log_streams}"
+        )

dbt_platform_helper/providers/s3.py

@@ -0,0 +1,21 @@
+import boto3
+from botocore.exceptions import ClientError
+
+from dbt_platform_helper.platform_exception import PlatformException
+
+
+class S3Provider:
+
+    def __init__(self, client: boto3.client):
+        self.client = client
+
+    def get_object(self, bucket_name: str, object_key: str) -> str:
+        """Returns an object from an S3 bucket."""
+
+        try:
+            content = self.client.get_object(Bucket=bucket_name, Key=object_key)
+            return content["Body"].read().decode("utf-8")
+        except ClientError as e:
+            raise PlatformException(
+                f"Failed to get '{object_key}' from '{bucket_name}'. Error: {e}"
+            )

dbt_platform_helper/providers/terraform_manifest.py

@@ -21,7 +21,6 @@ class TerraformManifestProvider:
         self,
         config_object,
         environment,
-        image_tag,
         platform_helper_version: str,
         platform_config,
         module_source_override: str = None,
@@ -36,7 +35,7 @@ class TerraformManifestProvider:
         terraform = {}
         self._add_header(terraform)
 
-        self._add_service_locals(terraform, environment, image_tag)
+        self._add_service_locals(terraform, environment)
 
         self._add_provider(terraform, account, deploy_to_account_id)
         self._add_backend(
@@ -47,15 +46,14 @@ class TerraformManifestProvider:
 
         self._write_terraform_json(terraform, service_dir)
 
-    def _add_service_locals(self, terraform, environment, image_tag):
+    def _add_service_locals(self, terraform, environment):
         terraform["locals"] = {
             "environment": environment,
-            "image_tag": image_tag,
             "platform_config": '${yamldecode(file("../../../../platform-config.yml"))}',
             "application": '${local.platform_config["application"]}',
             "environments": '${local.platform_config["environments"]}',
             "env_config": '${{for name, config in local.environments: name => merge(lookup(local.environments, "*", {}), config)}}',
-            "service_config": '${yamldecode(templatefile("./service-config.yml", {PLATFORM_ENVIRONMENT_NAME = local.environment, IMAGE_TAG = local.image_tag}))}',
+            "service_config": '${yamldecode(file("./service-config.yml"))}',
             "raw_env_config": '${local.platform_config["environments"]}',
             "combined_env_config": '${{for name, config in local.raw_env_config: name => merge(lookup(local.raw_env_config, "*", {}), config)}}',
             "service_deployment_mode": '${lookup(local.combined_env_config[local.environment], "service-deployment-mode", "copilot")}',

dbt_platform_helper/providers/yaml_file.py

@@ -98,18 +98,26 @@ class YamlFileProvider:
         return cleaned
 
     @staticmethod
-    def find_and_replace(config, string: str, replacement: str):
+    def find_and_replace(config, strings: list, replacements: list):
+        if len(strings) != len(replacements):
+            raise ValueError("'strings' and 'replacements' must be the same length.")
+        if not isinstance(strings, list) or not isinstance(replacements, list):
+            raise ValueError("'strings' and 'replacements' must both be lists.")
         if isinstance(config, (dict, OrderedDict)):
             return {
-                k: YamlFileProvider.find_and_replace(v, string, replacement)
+                k: YamlFileProvider.find_and_replace(v, strings, replacements)
                 for k, v in config.items()
             }
         elif isinstance(config, list):
-            return [YamlFileProvider.find_and_replace(item, string, replacement) for item in config]
+            return [
+                YamlFileProvider.find_and_replace(item, strings, replacements) for item in config
+            ]
         elif isinstance(config, str):
-            return config.replace(string, replacement)
+            for s, r in zip(strings, replacements):
+                config = config.replace(s, r)
+            return config
         else:
-            return replacement if config == string else config
+            return replacements if config == strings else config
 
 
 def account_number_representer(dumper, data):

dbt_platform_helper/utils/application.py

@@ -74,6 +74,7 @@ def load_application(app=None, default_session=None, env=None) -> Application:
         nesting.
 
         e.g.
+         - /platform/applications/test/environments/my_env will match.
          - /copilot/applications/test/environments/my_env will match.
          - /copilot/applications/test/environments/my_env/addons will not match.
         """
@@ -84,20 +85,24 @@ def load_application(app=None, default_session=None, env=None) -> Application:
 
     environments_data = []
 
-    # Try to load the new /platform SSM parameter if present
-    platform_env_path = f"/platform/applications/{application.name}/environments"
-    secrets = get_ssm_secrets(app, None, current_session, platform_env_path)
+    # Try to load all /platform SSM parameters that are present
+    env_params = get_ssm_secrets(
+        app=app,
+        env=None,
+        session=current_session,
+        path=f"/platform/applications/{application.name}/environments",
+    )
 
-    if secrets:
-        for name, value in secrets:
+    if env_params:
+        for name, value in env_params:
             try:
-                data = json.loads(value)
+                param_data = json.loads(value)
             except json.JSONDecodeError:
                 continue
 
-            # New /platform SSM parameter contains data about all environments
-            if "allEnvironments" in data:
-                environments_data = data["allEnvironments"]
+            # Each /platform SSM parameter contains data about all the environments of an application
+            if "allEnvironments" in param_data:
+                environments_data = param_data["allEnvironments"]
                 break  # Only need one
     else:
         try:
@@ -106,19 +111,20 @@ def load_application(app=None, default_session=None, env=None) -> Application:
                 Name=f"/copilot/applications/{application.name}",
                 WithDecryption=False,
             )
-            secrets = get_ssm_secrets(
+
+            # Legacy /copilot SSM parameters for each environment
+            env_params = get_ssm_secrets(
                 app, None, current_session, f"/copilot/applications/{application.name}/environments"
             )
 
-            for name, value in secrets:
+            for name, value in env_params:
                 try:
-                    data = json.loads(value)
+                    param_data = json.loads(value)
                 except json.JSONDecodeError:
                     continue
 
                 if is_environment_key(name):
-                    # Legacy /copilot SSM parameter. An individual SSM param is present per environment - looping through all of them is needed to extract necessary data about each env.
-                    environments_data.append(data)
+                    environments_data.append(param_data)
 
         except ssm_client.exceptions.ParameterNotFound:
             raise ApplicationNotFoundException(
@@ -130,6 +136,50 @@ def load_application(app=None, default_session=None, env=None) -> Application:
         for env in environments_data
     }
 
+    application.services = _load_services(ssm_client, application)
+
+    return application
+
+
+def _load_services(ssm_client, application: Application) -> Dict[str, Service]:
+    """
+    Try to load
+    /platform/applications/{app}/environments/{env}/services/{service}
+    parameters if present.
+
+    Otherwise, fall back to legacy /copilot/applications/{app}/components
+    parameters.
+    """
+    services: Dict[str, Service] = {}
+
+    # Try /platform SSM parameter
+    for env_name in application.environments.keys():
+        params = dict(
+            Path=f"/platform/applications/{application.name}/environments/{env_name}/services",
+            Recursive=False,
+            WithDecryption=False,
+        )
+
+        while True:
+            response = ssm_client.get_parameters_by_path(**params)
+            for ssm_param in response.get("Parameters", []):
+                try:
+                    data = json.loads(ssm_param["Value"])
+                    name = data["name"]
+                    kind = data["type"]
+                    services.setdefault(name, Service(name, kind))  # Avoid duplicates
+                except (json.JSONDecodeError, KeyError):
+                    continue
+
+            if "NextToken" in response:
+                params["NextToken"] = response["NextToken"]
+            else:
+                break
+
+    if services:
+        return services
+
+    # Fallback to legacy /copilot SSM parameter
     response = ssm_client.get_parameters_by_path(
         Path=f"/copilot/applications/{application.name}/components",
         Recursive=False,
@@ -145,12 +195,12 @@ def load_application(app=None, default_session=None, env=None) -> Application:
         )
         results.extend(response["Parameters"])
 
-    application.services = {
+    legacy_services = {
         svc["name"]: Service(svc["name"], svc["type"])
         for svc in [json.loads(parameter["Value"]) for parameter in results]
     }
 
-    return application
+    return legacy_services
 
 
 def get_application_name(abort=abort_with_error):

{dbt_platform_helper-15.10.0.dist-info → dbt_platform_helper-15.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbt-platform-helper
-Version: 15.10.0
+Version: 15.12.0
 Summary: Set of tools to help transfer applications/services from GOV.UK PaaS to DBT PaaS augmenting AWS Copilot.
 License: MIT
 License-File: LICENSE