dbt-platform-helper 12.2.3__py3-none-any.whl → 12.3.0__py3-none-any.whl

dbt_platform_helper/providers/copilot.py

@@ -5,11 +5,7 @@ from botocore.exceptions import ClientError
 
 from dbt_platform_helper.constants import CONDUIT_DOCKER_IMAGE_LOCATION
 from dbt_platform_helper.exceptions import CreateTaskTimeoutError
-from dbt_platform_helper.providers.ecs import get_ecs_task_arns
-from dbt_platform_helper.providers.secrets import get_connection_secret_arn
-from dbt_platform_helper.providers.secrets import (
-    get_postgres_connection_data_updated_with_master_secret,
-)
+from dbt_platform_helper.providers.secrets import Secrets
 from dbt_platform_helper.utils.application import Application
 from dbt_platform_helper.utils.messages import abort_with_error
 
@@ -59,7 +55,7 @@ def create_addon_client_task(
         # We cannot check for botocore.errorfactory.NoSuchEntityException as botocore generates that class on the fly as part of errorfactory.
         # factory. Checking the error code is the recommended way of handling these exceptions.
         if ex.response.get("Error", {}).get("Code", None) != "NoSuchEntity":
-            # TODO Raise an exception to be caught at the command layer
+            # TODO When we are refactoring this, raise an exception to be caught at the command layer
             abort_with_error(
                 f"cannot obtain Role {role_name}: {ex.response.get('Error', {}).get('Message', '')}"
             )
@@ -69,7 +65,7 @@ def create_addon_client_task(
         f"--task-group-name {task_name} "
         f"{execution_role}"
         f"--image {CONDUIT_DOCKER_IMAGE_LOCATION}:{addon_type} "
-        f"--secrets CONNECTION_SECRET={get_connection_secret_arn(ssm_client,secrets_manager_client, secret_name)} "
+        f"--secrets CONNECTION_SECRET={_get_secrets_provider(application, env).get_connection_secret_arn(secret_name)} "
         "--platform-os linux "
         "--platform-arch arm64",
         shell=True,
@@ -95,8 +91,8 @@ def create_postgres_admin_task(
         "Parameter"
     ]["Value"]
     connection_string = json.dumps(
-        get_postgres_connection_data_updated_with_master_secret(
-            ssm_client, secrets_manager_client, read_only_secret_name, master_secret_arn
+        _get_secrets_provider(app, env).get_postgres_connection_data_updated_with_master_secret(
+            read_only_secret_name, master_secret_arn
         )
     )
 
@@ -111,6 +107,19 @@ def create_postgres_admin_task(
     )
 
 
+def _temp_until_refactor_get_ecs_task_arns(ecs_client, cluster_arn: str, task_name: str):
+    tasks = ecs_client.list_tasks(
+        cluster=cluster_arn,
+        desiredStatus="RUNNING",
+        family=f"copilot-{task_name}",
+    )
+
+    if not tasks["taskArns"]:
+        return []
+
+    return tasks["taskArns"]
+
+
 def connect_to_addon_client_task(
     ecs_client,
     subprocess,
@@ -118,13 +127,14 @@ def connect_to_addon_client_task(
     env,
     cluster_arn,
     task_name,
-    addon_client_is_running_fn=get_ecs_task_arns,
+    get_ecs_task_arns=_temp_until_refactor_get_ecs_task_arns,
 ):
     running = False
     tries = 0
     while tries < 15 and not running:
         tries += 1
-        if addon_client_is_running_fn(ecs_client, cluster_arn, task_name):
+        # Todo: Use from ECS provider when we refactor this
+        if get_ecs_task_arns(ecs_client, cluster_arn, task_name):
             subprocess.call(
                 "copilot task exec "
                 f"--app {application_name} --env {env} "
@@ -137,8 +147,18 @@ def connect_to_addon_client_task(
         time.sleep(1)
 
     if not running:
-        raise CreateTaskTimeoutError
+        raise CreateTaskTimeoutError(task_name, application_name, env)
 
 
 def _normalise_secret_name(addon_name: str) -> str:
     return addon_name.replace("-", "_").upper()
+
+
+def _get_secrets_provider(application: Application, env: str) -> Secrets:
+    # Todo: We instantiate the secrets provider here to avoid rabbit holing, but something better probably possible when we are refactoring this area
+    return Secrets(
+        application.environments[env].session.client("ssm"),
+        application.environments[env].session.client("secretsmanager"),
+        application.name,
+        env,
+    )

dbt_platform_helper/providers/ecs.py

@@ -7,73 +7,81 @@ from dbt_platform_helper.exceptions import ECSAgentNotRunning
 from dbt_platform_helper.exceptions import NoClusterError
 
 
-# Todo: Refactor to a class, review, then perhaps do the others
-def get_cluster_arn(ecs_client, application_name: str, env: str) -> str:
-    for cluster_arn in ecs_client.list_clusters()["clusterArns"]:
-        tags_response = ecs_client.list_tags_for_resource(resourceArn=cluster_arn)
-        tags = tags_response["tags"]
-
-        app_key_found = False
-        env_key_found = False
-        cluster_key_found = False
-
-        for tag in tags:
-            if tag["key"] == "copilot-application" and tag["value"] == application_name:
-                app_key_found = True
-            if tag["key"] == "copilot-environment" and tag["value"] == env:
-                env_key_found = True
-            if tag["key"] == "aws:cloudformation:logical-id" and tag["value"] == "Cluster":
-                cluster_key_found = True
-
-        if app_key_found and env_key_found and cluster_key_found:
-            return cluster_arn
-
-    raise NoClusterError
-
-
-def get_or_create_task_name(
-    ssm_client, application_name: str, env: str, addon_name: str, parameter_name: str
-) -> str:
-    try:
-        return ssm_client.get_parameter(Name=parameter_name)["Parameter"]["Value"]
-    except ssm_client.exceptions.ParameterNotFound:
-        random_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=12))
-        return f"conduit-{application_name}-{env}-{addon_name}-{random_id}"
-
-
-def get_ecs_task_arns(ecs_client, cluster_arn: str, task_name: str):
-
-    tasks = ecs_client.list_tasks(
-        cluster=cluster_arn,
-        desiredStatus="RUNNING",
-        family=f"copilot-{task_name}",
-    )
-
-    if not tasks["taskArns"]:
-        return []
-
-    return tasks["taskArns"]
-
-
-def ecs_exec_is_available(ecs_client, cluster_arn: str, task_arns: List[str]):
-
-    current_attemps = 0
-    execute_command_agent_status = ""
-
-    while execute_command_agent_status != "RUNNING" and current_attemps < 25:
-
-        current_attemps += 1
-
-        task_details = 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]
-
-        time.sleep(1)
-
-    if execute_command_agent_status != "RUNNING":
-        raise ECSAgentNotRunning
+class ECS:
+    def __init__(self, ecs_client, ssm_client, application_name: str, env: str):
+        self.ecs_client = ecs_client
+        self.ssm_client = ssm_client
+        self.application_name = application_name
+        self.env = env
+
+    def get_cluster_arn(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"]:
+            tags_response = self.ecs_client.list_tags_for_resource(resourceArn=cluster_arn)
+            tags = tags_response["tags"]
+
+            app_key_found = False
+            env_key_found = False
+            cluster_key_found = False
+
+            for tag in tags:
+                if tag["key"] == "copilot-application" and tag["value"] == self.application_name:
+                    app_key_found = True
+                if tag["key"] == "copilot-environment" and tag["value"] == self.env:
+                    env_key_found = True
+                if tag["key"] == "aws:cloudformation:logical-id" and tag["value"] == "Cluster":
+                    cluster_key_found = True
+
+            if app_key_found and env_key_found and cluster_key_found:
+                return cluster_arn
+
+        raise NoClusterError(self.application_name, self.env)
+
+    def get_or_create_task_name(self, addon_name: str, parameter_name: str) -> str:
+        """Fetches the task name from SSM or creates a new one if not found."""
+        try:
+            return self.ssm_client.get_parameter(Name=parameter_name)["Parameter"]["Value"]
+        except self.ssm_client.exceptions.ParameterNotFound:
+            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):
+        """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}",
+        )
+
+        if not tasks["taskArns"]:
+            return []
+
+        return tasks["taskArns"]
+
+    def ecs_exec_is_available(self, cluster_arn: str, task_arns: List[str]):
+        """
+        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 ECSAgentNotRunning

dbt_platform_helper/providers/secrets.py

@@ -9,77 +9,77 @@ from dbt_platform_helper.exceptions import ParameterNotFoundError
 from dbt_platform_helper.exceptions import SecretNotFoundError
 
 
-def get_postgres_connection_data_updated_with_master_secret(
-    ssm_client, secrets_manager_client, parameter_name, secret_arn
-):
-    response = ssm_client.get_parameter(Name=parameter_name, WithDecryption=True)
-    parameter_value = response["Parameter"]["Value"]
-
-    parameter_data = json.loads(parameter_value)
-
-    secret_response = secrets_manager_client.get_secret_value(SecretId=secret_arn)
-    secret_value = json.loads(secret_response["SecretString"])
-
-    parameter_data["username"] = urllib.parse.quote(secret_value["username"])
-    parameter_data["password"] = urllib.parse.quote(secret_value["password"])
-
-    return parameter_data
-
-
-def get_connection_secret_arn(ssm_client, secrets_manager_client, secret_name: str) -> str:
-
-    try:
-        return ssm_client.get_parameter(Name=secret_name, WithDecryption=False)["Parameter"]["ARN"]
-    except ssm_client.exceptions.ParameterNotFound:
-        pass
-
-    try:
-        return secrets_manager_client.describe_secret(SecretId=secret_name)["ARN"]
-    except secrets_manager_client.exceptions.ResourceNotFoundException:
-        pass
-
-    raise SecretNotFoundError(secret_name)
-
-
-def get_addon_type(ssm_client, application_name: str, env: str, addon_name: str) -> str:
-    addon_type = None
-    try:
-        addon_config = json.loads(
-            ssm_client.get_parameter(
-                Name=f"/copilot/applications/{application_name}/environments/{env}/addons"
-            )["Parameter"]["Value"]
-        )
-    except ssm_client.exceptions.ParameterNotFound:
-        raise ParameterNotFoundError
-
-    if addon_name not in addon_config.keys():
-        raise AddonNotFoundError
-
-    for name, config in addon_config.items():
-        if name == addon_name:
-            if not config.get("type"):
-                raise AddonTypeMissingFromConfigError()
-            addon_type = config["type"]
-
-    if not addon_type or addon_type not in CONDUIT_ADDON_TYPES:
-        raise InvalidAddonTypeError(addon_type)
-
-    if "postgres" in addon_type:
-        addon_type = "postgres"
-
-    return addon_type
-
-
-def get_parameter_name(
-    application_name: str, env: str, addon_type: str, addon_name: str, access: str
-) -> str:
-    if addon_type == "postgres":
-        return f"/copilot/{application_name}/{env}/conduits/{_normalise_secret_name(addon_name)}_{access.upper()}"
-    elif addon_type == "redis" or addon_type == "opensearch":
-        return f"/copilot/{application_name}/{env}/conduits/{_normalise_secret_name(addon_name)}_ENDPOINT"
-    else:
-        return f"/copilot/{application_name}/{env}/conduits/{_normalise_secret_name(addon_name)}"
-
-
-def _normalise_secret_name(addon_name: str) -> str:
-    return addon_name.replace("-", "_").upper()
+class Secrets:
+    def __init__(self, ssm_client, secrets_manager_client, application_name, env):
+        self.ssm_client = ssm_client
+        self.secrets_manager_client = secrets_manager_client
+        self.application_name = application_name
+        self.env = env
+
+    def get_postgres_connection_data_updated_with_master_secret(self, parameter_name, secret_arn):
+        response = self.ssm_client.get_parameter(Name=parameter_name, WithDecryption=True)
+        parameter_value = response["Parameter"]["Value"]
+
+        parameter_data = json.loads(parameter_value)
+
+        secret_response = self.secrets_manager_client.get_secret_value(SecretId=secret_arn)
+        secret_value = json.loads(secret_response["SecretString"])
+
+        parameter_data["username"] = urllib.parse.quote(secret_value["username"])
+        parameter_data["password"] = urllib.parse.quote(secret_value["password"])
+
+        return parameter_data
+
+    def get_connection_secret_arn(self, secret_name: str) -> str:
+        try:
+            return self.ssm_client.get_parameter(Name=secret_name, WithDecryption=False)[
+                "Parameter"
+            ]["ARN"]
+        except self.ssm_client.exceptions.ParameterNotFound:
+            pass
+
+        try:
+            return self.secrets_manager_client.describe_secret(SecretId=secret_name)["ARN"]
+        except self.secrets_manager_client.exceptions.ResourceNotFoundException:
+            pass
+
+        raise SecretNotFoundError(secret_name)
+
+    def get_addon_type(self, addon_name: str) -> str:
+        addon_type = None
+        try:
+            addon_config = json.loads(
+                self.ssm_client.get_parameter(
+                    Name=f"/copilot/applications/{self.application_name}/environments/{self.env}/addons"
+                )["Parameter"]["Value"]
+            )
+        except self.ssm_client.exceptions.ParameterNotFound:
+            raise ParameterNotFoundError(self.application_name, self.env)
+
+        if addon_name not in addon_config.keys():
+            raise AddonNotFoundError(addon_name)
+
+        for name, config in addon_config.items():
+            if name == addon_name:
+                if not config.get("type"):
+                    raise AddonTypeMissingFromConfigError(addon_name)
+                addon_type = config["type"]
+
+        if not addon_type or addon_type not in CONDUIT_ADDON_TYPES:
+            raise InvalidAddonTypeError(addon_type)
+
+        if "postgres" in addon_type:
+            addon_type = "postgres"
+
+        return addon_type
+
+    def get_parameter_name(self, addon_type: str, addon_name: str, access: str) -> str:
+        if addon_type == "postgres":
+            return f"/copilot/{self.application_name}/{self.env}/conduits/{self._normalise_secret_name(addon_name)}_{access.upper()}"
+        elif addon_type == "redis" or addon_type == "opensearch":
+            return f"/copilot/{self.application_name}/{self.env}/conduits/{self._normalise_secret_name(addon_name)}_ENDPOINT"
+        else:
+            return f"/copilot/{self.application_name}/{self.env}/conduits/{self._normalise_secret_name(addon_name)}"
+
+    def _normalise_secret_name(self, addon_name: str) -> str:
+        return addon_name.replace("-", "_").upper()

dbt_platform_helper/utils/application.py

@@ -80,7 +80,7 @@ def load_application(app: str = None, default_session: Session = None) -> Applic
             WithDecryption=False,
         )
     except ssm_client.exceptions.ParameterNotFound:
-        raise ApplicationNotFoundError
+        raise ApplicationNotFoundError(app)
 
     path = f"/copilot/applications/{application.name}/environments"
     secrets = get_ssm_secrets(app, None, current_session, path)

dbt_platform_helper/utils/aws.py

@@ -1,5 +1,6 @@
 import json
 import os
+import time
 import urllib.parse
 from configparser import ConfigParser
 from pathlib import Path
@@ -15,6 +16,7 @@ from boto3 import Session
 from dbt_platform_helper.exceptions import AWSException
 from dbt_platform_helper.exceptions import CopilotCodebaseNotFoundError
 from dbt_platform_helper.exceptions import ImageNotFoundError
+from dbt_platform_helper.exceptions import ResourceNotFoundException
 from dbt_platform_helper.exceptions import ValidationException
 from dbt_platform_helper.utils.files import cache_refresh_required
 from dbt_platform_helper.utils.files import read_supported_versions_from_cache
@@ -340,6 +342,7 @@ def get_load_balancer_configuration(
 
 
 def get_postgres_connection_data_updated_with_master_secret(session, parameter_name, secret_arn):
+    # Todo: This is pretty much the same as dbt_platform_helper.providers.secrets.Secrets.get_postgres_connection_data_updated_with_master_secret
     ssm_client = session.client("ssm")
     secrets_manager_client = session.client("secretsmanager")
     response = ssm_client.get_parameter(Name=parameter_name, WithDecryption=True)
@@ -414,7 +417,7 @@ def get_connection_string(
     app: str,
     env: str,
     db_identifier: str,
-    connection_data_fn=get_postgres_connection_data_updated_with_master_secret,
+    connection_data=get_postgres_connection_data_updated_with_master_secret,
 ) -> str:
     addon_name = db_identifier.split(f"{app}-{env}-", 1)[1]
     normalised_addon_name = addon_name.replace("-", "_").upper()
@@ -426,7 +429,7 @@ def get_connection_string(
         Name=master_secret_name, WithDecryption=True
     )["Parameter"]["Value"]
 
-    conn = connection_data_fn(session, connection_string_parameter, master_secret_arn)
+    conn = connection_data(session, connection_string_parameter, master_secret_arn)
 
     return f"postgres://{conn['username']}:{conn['password']}@{conn['host']}:{conn['port']}/{conn['dbname']}"
 
@@ -499,7 +502,7 @@ def check_codebase_exists(session: Session, application, codebase: str):
         ssm_client.exceptions.ParameterNotFound,
         json.JSONDecodeError,
     ):
-        raise CopilotCodebaseNotFoundError
+        raise CopilotCodebaseNotFoundError(codebase)
 
 
 def check_image_exists(session, application, codebase, commit):
@@ -513,7 +516,7 @@ def check_image_exists(session, application, codebase, commit):
         ecr_client.exceptions.RepositoryNotFoundException,
         ecr_client.exceptions.ImageNotFoundException,
     ):
-        raise ImageNotFoundError
+        raise ImageNotFoundError(commit)
 
 
 def get_build_url_from_arn(build_arn: str) -> str:
@@ -525,7 +528,7 @@ def get_build_url_from_arn(build_arn: str) -> str:
     )
 
 
-def list_latest_images(ecr_client, ecr_repository_name, codebase_repository, echo_fn):
+def list_latest_images(ecr_client, ecr_repository_name, codebase_repository, echo):
     paginator = ecr_client.get_paginator("describe_images")
     describe_images_response_iterator = paginator.paginate(
         repositoryName=ecr_repository_name,
@@ -550,8 +553,28 @@ def list_latest_images(ecr_client, ecr_repository_name, codebase_repository, ech
                 continue
 
             commit_hash = commit_tag.replace("commit-", "")
-            echo_fn(
+            echo(
                 f"  - https://github.com/{codebase_repository}/commit/{commit_hash} - published: {image['imagePushedAt']}"
             )
         except StopIteration:
             continue
+
+
+def wait_for_log_group_to_exist(log_client, log_group_name, attempts=30):
+    current_attempts = 0
+    log_group_exists = False
+
+    while not log_group_exists and current_attempts < attempts:
+        current_attempts += 1
+
+        log_group_response = log_client.describe_log_groups(logGroupNamePrefix=log_group_name)
+        log_groups = log_group_response.get("logGroups", [])
+
+        for group in log_groups:
+            if group["logGroupName"] == log_group_name:
+                log_group_exists = True
+
+        time.sleep(1)
+
+    if not log_group_exists:
+        raise ResourceNotFoundException

dbt_platform_helper/utils/validation.py

@@ -104,13 +104,13 @@ def validate_addons(addons: dict):
         config={"extensions": addons},
         extension_type="redis",
         version_key="engine",
-        get_supported_versions_fn=get_supported_redis_versions,
+        get_supported_versions=get_supported_redis_versions,
     )
     _validate_extension_supported_versions(
         config={"extensions": addons},
         extension_type="opensearch",
         version_key="engine",
-        get_supported_versions_fn=get_supported_opensearch_versions,
+        get_supported_versions=get_supported_opensearch_versions,
     )
 
     return errors
@@ -210,7 +210,12 @@ RETENTION_POLICY = Or(
     },
 )
 
-DATABASE_COPY = {"from": ENV_NAME, "to": ENV_NAME}
+DATABASE_COPY = {
+    "from": ENV_NAME,
+    "to": ENV_NAME,
+    Optional("from_account"): str,
+    Optional("to_account"): str,
+}
 
 POSTGRES_DEFINITION = {
     "type": "postgres",
@@ -558,18 +563,18 @@ def validate_platform_config(config):
         config=config,
         extension_type="redis",
         version_key="engine",
-        get_supported_versions_fn=get_supported_redis_versions,
+        get_supported_versions=get_supported_redis_versions,
     )
     _validate_extension_supported_versions(
         config=config,
         extension_type="opensearch",
         version_key="engine",
-        get_supported_versions_fn=get_supported_opensearch_versions,
+        get_supported_versions=get_supported_opensearch_versions,
     )
 
 
 def _validate_extension_supported_versions(
-    config, extension_type, version_key, get_supported_versions_fn
+    config, extension_type, version_key, get_supported_versions
 ):
     extensions = config.get("extensions", {})
     if not extensions:
@@ -581,7 +586,7 @@ def _validate_extension_supported_versions(
         if extension.get("type") == extension_type
     ]
 
-    supported_extension_versions = get_supported_versions_fn()
+    supported_extension_versions = get_supported_versions()
     extensions_with_invalid_version = []
 
     for extension in extensions_for_type:
@@ -590,13 +595,16 @@ def _validate_extension_supported_versions(
 
         if not isinstance(environments, dict):
             click.secho(
-                "Error: Opensearch extension definition is invalid type, expected dictionary",
+                f"Error: {extension_type} extension definition is invalid type, expected dictionary",
                 fg="red",
             )
             continue
         for environment, env_config in environments.items():
+
+            # An extension version doesn't need to be specified for all environments, provided one is specified under "*".
+            # So check if the version is set before checking if it's supported
             extension_version = env_config.get(version_key)
-            if extension_version not in supported_extension_versions:
+            if extension_version and extension_version not in supported_extension_versions:
                 extensions_with_invalid_version.append(
                     {"environment": environment, "version": extension_version}
                 )
@@ -635,6 +643,9 @@ def validate_database_copy_section(config):
             from_env = section["from"]
             to_env = section["to"]
 
+            from_account = _get_env_deploy_account_info(config, from_env, "id")
+            to_account = _get_env_deploy_account_info(config, to_env, "id")
+
             if from_env == to_env:
                 errors.append(
                     f"database_copy 'to' and 'from' cannot be the same environment in extension '{extension_name}'."
@@ -655,10 +666,33 @@ def validate_database_copy_section(config):
                     f"database_copy 'to' parameter must be a valid environment ({all_envs_string}) but was '{to_env}' in extension '{extension_name}'."
                 )
 
+            if from_account != to_account:
+                if "from_account" not in section:
+                    errors.append(
+                        f"Environments '{from_env}' and '{to_env}' are in different AWS accounts. The 'from_account' parameter must be present."
+                    )
+                elif section["from_account"] != from_account:
+                    errors.append(
+                        f"Incorrect value for 'from_account' for environment '{from_env}'"
+                    )
+
+                if "to_account" not in section:
+                    errors.append(
+                        f"Environments '{from_env}' and '{to_env}' are in different AWS accounts. The 'to_account' parameter must be present."
+                    )
+                elif section["to_account"] != to_account:
+                    errors.append(f"Incorrect value for 'to_account' for environment '{to_env}'")
+
     if errors:
         abort_with_error("\n".join(errors))
 
 
+def _get_env_deploy_account_info(config, env, key):
+    return (
+        config.get("environments", {}).get(env, {}).get("accounts", {}).get("deploy", {}).get(key)
+    )
+
+
 def _validate_environment_pipelines(config):
     bad_pipelines = {}
     for pipeline_name, pipeline in config.get("environment_pipelines", {}).items():
@@ -666,13 +700,7 @@ def _validate_environment_pipelines(config):
         pipeline_account = pipeline.get("account", None)
         if pipeline_account:
             for env in pipeline.get("environments", {}).keys():
-                env_account = (
-                    config.get("environments", {})
-                    .get(env, {})
-                    .get("accounts", {})
-                    .get("deploy", {})
-                    .get("name")
-                )
+                env_account = _get_env_deploy_account_info(config, env, "name")
                 if not env_account == pipeline_account:
                     bad_envs.append(env)
         if bad_envs:

{dbt_platform_helper-12.2.3.dist-info → dbt_platform_helper-12.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbt-platform-helper
-Version: 12.2.3
+Version: 12.3.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