dbt-platform-helper 12.6.0__py3-none-any.whl → 13.0.1__py3-none-any.whl

dbt_platform_helper/domain/pipelines.py

@@ -5,14 +5,14 @@ from shutil import rmtree
 
 from dbt_platform_helper.constants import CODEBASE_PIPELINES_KEY
 from dbt_platform_helper.constants import ENVIRONMENT_PIPELINES_KEY
-from dbt_platform_helper.constants import ENVIRONMENTS_KEY
+from dbt_platform_helper.constants import SUPPORTED_AWS_PROVIDER_VERSION
+from dbt_platform_helper.constants import SUPPORTED_TERRAFORM_VERSION
 from dbt_platform_helper.providers.config import ConfigProvider
+from dbt_platform_helper.providers.ecr import ECRProvider
 from dbt_platform_helper.providers.files import FileProvider
 from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.terraform_manifest import TerraformManifestProvider
 from dbt_platform_helper.utils.application import get_application_name
-from dbt_platform_helper.utils.aws import get_account_details
-from dbt_platform_helper.utils.aws import get_public_repository_arn
-from dbt_platform_helper.utils.files import generate_override_files_from_template
 from dbt_platform_helper.utils.template import setup_templates
 from dbt_platform_helper.utils.versioning import (
     get_required_terraform_platform_modules_version,
@@ -23,30 +23,35 @@ class Pipelines:
     def __init__(
         self,
         config_provider: ConfigProvider,
+        terraform_manifest_provider: TerraformManifestProvider,
+        ecr_provider: ECRProvider,
         get_git_remote: Callable[[], str],
         get_codestar_arn: Callable[[str], str],
         io: ClickIOProvider = ClickIOProvider(),
+        file_provider: FileProvider = FileProvider(),
     ):
         self.config_provider = config_provider
         self.get_git_remote = get_git_remote
         self.get_codestar_arn = get_codestar_arn
+        self.terraform_manifest_provider = terraform_manifest_provider
+        self.ecr_provider = ecr_provider
         self.io = io
+        self.file_provider = file_provider
 
-    def generate(self, terraform_platform_modules_version, deploy_branch):
-        pipeline_config = self.config_provider.load_and_validate_platform_config()
+    def generate(self, cli_terraform_platform_modules_version: str, deploy_branch: str):
+        platform_config = self.config_provider.load_and_validate_platform_config()
 
-        has_codebase_pipelines = CODEBASE_PIPELINES_KEY in pipeline_config
-        has_environment_pipelines = ENVIRONMENT_PIPELINES_KEY in pipeline_config
+        has_codebase_pipelines = CODEBASE_PIPELINES_KEY in platform_config
+        has_environment_pipelines = ENVIRONMENT_PIPELINES_KEY in platform_config
 
         if not (has_codebase_pipelines or has_environment_pipelines):
             self.io.warn("No pipelines defined: nothing to do.")
             return
 
-        platform_config_terraform_modules_default_version = pipeline_config.get(
+        platform_config_terraform_modules_default_version = platform_config.get(
             "default_versions", {}
         ).get("terraform-platform-modules", "")
 
-        templates = setup_templates()
         app_name = get_application_name()
 
         git_repo = self.get_git_remote()
@@ -62,151 +67,72 @@ class Pipelines:
 
         self._clean_pipeline_config(copilot_pipelines_dir)
 
+        terraform_platform_modules_version = get_required_terraform_platform_modules_version(
+            cli_terraform_platform_modules_version,
+            platform_config_terraform_modules_default_version,
+        )
+
         if has_environment_pipelines:
-            environment_pipelines = pipeline_config[ENVIRONMENT_PIPELINES_KEY]
+            environment_pipelines = platform_config[ENVIRONMENT_PIPELINES_KEY]
+            accounts = {
+                config.get("account")
+                for config in environment_pipelines.values()
+                if "account" in config
+            }
 
-            for config in environment_pipelines.values():
-                aws_account = config.get("account")
+            for account in accounts:
                 self._generate_terraform_environment_pipeline_manifest(
-                    pipeline_config["application"],
-                    aws_account,
+                    platform_config["application"],
+                    account,
                     terraform_platform_modules_version,
-                    platform_config_terraform_modules_default_version,
                     deploy_branch,
                 )
 
         if has_codebase_pipelines:
-            account_id, _ = get_account_details()
-
-            for codebase in pipeline_config[CODEBASE_PIPELINES_KEY]:
-                self._generate_codebase_pipeline(
-                    account_id,
-                    app_name,
-                    codestar_connection_arn,
-                    git_repo,
-                    codebase,
-                    base_path,
-                    copilot_pipelines_dir,
-                    templates,
-                )
+            codebase_pipelines = platform_config[CODEBASE_PIPELINES_KEY]
+            ecrs_to_be_managed = {
+                codebase: f"{platform_config['application']}/{codebase}"
+                for codebase in codebase_pipelines.keys()
+            }
+            ecrs_already_provisioned = set(self.ecr_provider.get_ecr_repo_names())
+            ecrs_that_need_importing = {
+                codebase: repo
+                for codebase, repo in ecrs_to_be_managed.items()
+                if repo in ecrs_already_provisioned
+            }
 
-    def _clean_pipeline_config(self, pipelines_dir):
+            self.terraform_manifest_provider.generate_codebase_pipeline_config(
+                platform_config, terraform_platform_modules_version, ecrs_that_need_importing
+            )
+
+    def _clean_pipeline_config(self, pipelines_dir: Path):
         if pipelines_dir.exists():
             self.io.info("Deleting copilot/pipelines directory.")
             rmtree(pipelines_dir)
 
-    def _generate_codebase_pipeline(
-        self,
-        account_id,
-        app_name,
-        codestar_connection_arn,
-        git_repo,
-        codebase,
-        base_path,
-        pipelines_dir,
-        templates,
-    ):
-        makedirs(pipelines_dir / codebase["name"] / "overrides", exist_ok=True)
-        environments = []
-        for pipelines in codebase["pipelines"]:
-            environments += pipelines[ENVIRONMENTS_KEY]
-
-        additional_ecr = codebase.get("additional_ecr_repository", None)
-        add_public_perms = additional_ecr and additional_ecr.startswith("public.ecr.aws")
-        additional_ecr_arn = get_public_repository_arn(additional_ecr) if add_public_perms else None
-
-        template_data = {
-            "account_id": account_id,
-            "app_name": app_name,
-            "deploy_repo": git_repo,
-            "codebase": codebase,
-            ENVIRONMENTS_KEY: environments,
-            "codestar_connection_arn": codestar_connection_arn,
-            "codestar_connection_id": codestar_connection_arn.split("/")[-1],
-            "additional_ecr_arn": additional_ecr_arn,
-        }
-
-        self._create_file_from_template(
-            base_path,
-            f"{codebase['name']}/manifest.yml",
-            pipelines_dir,
-            template_data,
-            templates,
-            "codebase/manifest.yml",
-        )
-
-        overrides_path = Path(__file__).parent.parent.joinpath(
-            "templates/pipelines/codebase/overrides"
-        )
-        generate_override_files_from_template(
-            base_path, overrides_path, pipelines_dir / codebase["name"] / "overrides", template_data
-        )
-
-    def _create_file_from_template(
-        self, base_path, file_name, pipelines_dir, template_data, templates, template_name=None
-    ):
-        contents = templates.get_template(
-            f"pipelines/{file_name if template_name is None else template_name}"
-        ).render(template_data)
-        message = FileProvider.mkfile(
-            base_path, pipelines_dir / file_name, contents, overwrite=True
-        )
-        self.io.info(message)
-
     def _generate_terraform_environment_pipeline_manifest(
         self,
-        application,
-        aws_account,
-        cli_terraform_platform_modules_version,
-        platform_config_terraform_modules_default_version,
-        deploy_branch,
+        application: str,
+        aws_account: str,
+        terraform_platform_modules_version: str,
+        deploy_branch: str,
     ):
         env_pipeline_template = setup_templates().get_template("environment-pipelines/main.tf")
 
-        terraform_platform_modules_version = get_required_terraform_platform_modules_version(
-            cli_terraform_platform_modules_version,
-            platform_config_terraform_modules_default_version,
-        )
-
         contents = env_pipeline_template.render(
             {
                 "application": application,
                 "aws_account": aws_account,
                 "terraform_platform_modules_version": terraform_platform_modules_version,
                 "deploy_branch": deploy_branch,
+                "terraform_version": SUPPORTED_TERRAFORM_VERSION,
+                "aws_provider_version": SUPPORTED_AWS_PROVIDER_VERSION,
             }
         )
 
         dir_path = f"terraform/environment-pipelines/{aws_account}"
         makedirs(dir_path, exist_ok=True)
 
-        self.io.info(FileProvider.mkfile(".", f"{dir_path}/main.tf", contents, overwrite=True))
-
-    def generate_terraform_codebase_pipeline_manifest(
-        self,
-        application,
-        aws_account,
-        cli_terraform_platform_modules_version,
-        platform_config_terraform_modules_default_version,
-        deploy_branch,
-    ):
-        env_pipeline_template = setup_templates().get_template("codebase-pipelines/main.tf")
-
-        terraform_platform_modules_version = get_required_terraform_platform_modules_version(
-            cli_terraform_platform_modules_version,
-            platform_config_terraform_modules_default_version,
-        )
-
-        contents = env_pipeline_template.render(
-            {
-                "application": application,
-                "aws_account": aws_account,
-                "terraform_platform_modules_version": terraform_platform_modules_version,
-                "deploy_branch": deploy_branch,
-            }
+        self.io.info(
+            self.file_provider.mkfile(".", f"{dir_path}/main.tf", contents, overwrite=True)
         )
-
-        dir_path = f"terraform/environment-pipelines/{aws_account}"
-        makedirs(dir_path, exist_ok=True)
-
-        self.io.info(FileProvider.mkfile(".", f"{dir_path}/main.tf", contents, overwrite=True))

dbt_platform_helper/domain/terraform_environment.py

@@ -1,6 +1,8 @@
 import click
 
 from dbt_platform_helper.constants import DEFAULT_TERRAFORM_PLATFORM_MODULES_VERSION
+from dbt_platform_helper.constants import SUPPORTED_AWS_PROVIDER_VERSION
+from dbt_platform_helper.constants import SUPPORTED_TERRAFORM_VERSION
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.files import FileProvider
 from dbt_platform_helper.utils.template import setup_templates
@@ -31,6 +33,8 @@ class PlatformTerraformManifestGenerator:
                 "environment": environment_name,
                 "config": environment_config,
                 "terraform_platform_modules_version": terraform_platform_modules_version,
+                "terraform_version": SUPPORTED_TERRAFORM_VERSION,
+                "aws_provider_version": SUPPORTED_AWS_PROVIDER_VERSION,
             }
         )
 

dbt_platform_helper/providers/aws.py

@@ -19,6 +19,11 @@ class ImageNotFoundException(AWSException):
         )
 
 
+class RepositoryNotFoundException(AWSException):
+    def __init__(self, repository: str):
+        super().__init__(f"""The ECR repository "{repository}" could not be found.""")
+
+
 class LogGroupNotFoundException(AWSException):
     def __init__(self, log_group_name: str):
         super().__init__(f"""No log group called "{log_group_name}".""")

dbt_platform_helper/providers/config.py

@@ -28,7 +28,7 @@ class ConfigProvider:
     def get_enriched_config(self):
         return self.apply_environment_defaults(self.load_and_validate_platform_config())
 
-    def validate_platform_config(self):
+    def _validate_platform_config(self):
         PlatformConfigSchema.schema().validate(self.config)
 
         # TODO= logically this isn't validation but loading + parsing, to move.
@@ -48,7 +48,7 @@ class ConfigProvider:
             self.io.abort_with_error(f"Error loading configuration from {path}: {e}")
 
         try:
-            self.validate_platform_config()
+            self._validate_platform_config()
         except SchemaError as e:
             self.io.abort_with_error(f"Schema error in {path}. {e}")
 

dbt_platform_helper/providers/ecr.py

@@ -0,0 +1,20 @@
+from boto3 import Session
+
+from dbt_platform_helper.utils.aws import get_aws_session_or_abort
+
+
+class ECRProvider:
+    def __init__(self, session: Session = None):
+        self.session = session
+        self.client = None
+
+    def _get_client(self):
+        if not self.session:
+            self.session = get_aws_session_or_abort()
+        return self.session.client("ecr")
+
+    def get_ecr_repo_names(self) -> list[str]:
+        out = []
+        for page in self._get_client().get_paginator("describe_repositories").paginate():
+            out.extend([repo["repositoryName"] for repo in page.get("repositories", {})])
+        return out

dbt_platform_helper/providers/files.py

@@ -8,7 +8,7 @@ class FileProvider:
         pass
 
     @staticmethod
-    def mkfile(base_path: str, file_path: str, contents, overwrite=False) -> str:
+    def mkfile(base_path: str, file_path: str, contents: str, overwrite=False) -> str:
         file_path = Path(file_path)
         file = Path(base_path).joinpath(file_path)
         file_exists = file.exists()

dbt_platform_helper/providers/load_balancers.py

@@ -21,7 +21,9 @@ def get_load_balancer_for_application(session: boto3.Session, app: str, env: str
             load_balancer_arn = lb["ResourceArn"]
 
     if not load_balancer_arn:
-        raise LoadBalancerNotFoundException()
+        raise LoadBalancerNotFoundException(
+            f"No load balancer found for {app} in the {env} environment"
+        )
 
     return load_balancer_arn
 
@@ -39,7 +41,7 @@ def get_https_listener_for_application(session: boto3.Session, app: str, env: st
         pass
 
     if not listener_arn:
-        raise ListenerNotFoundException()
+        raise ListenerNotFoundException(f"No HTTPS listener for {app} in the {env} environment")
 
     return listener_arn
 

dbt_platform_helper/providers/platform_config_schema.py

@@ -16,9 +16,7 @@ class PlatformConfigSchema:
             {
                 # The following line is for the AWS Copilot version, will be removed under DBTP-1002
                 "application": str,
-                Optional("legacy_project", default=False): bool,
                 Optional("default_versions"): PlatformConfigSchema.__default_versions_schema(),
-                Optional("accounts"): list[str],
                 Optional("environments"): PlatformConfigSchema.__environments_schema(),
                 Optional("codebase_pipelines"): PlatformConfigSchema.__codebase_pipelines_schema(),
                 Optional(
@@ -80,7 +78,7 @@ class PlatformConfigSchema:
                 "cache": str,
                 "request": str,
             },
-            Optional("additional"): list[
+            Optional("additional"): [
                 {
                     "path": str,
                     "cache": str,
@@ -94,12 +92,12 @@ class PlatformConfigSchema:
             Optional("environments"): {
                 PlatformConfigSchema.__valid_environment_name(): Or(
                     {
-                        Optional("additional_address_list"): list,
-                        Optional("allowed_methods"): list,
-                        Optional("cached_methods"): list,
+                        Optional("additional_address_list"): [str],
+                        Optional("allowed_methods"): [str],
+                        Optional("cached_methods"): [str],
                         Optional("cdn_compress"): bool,
                         Optional("cdn_domains_list"): dict,
-                        Optional("cdn_geo_locations"): list,
+                        Optional("cdn_geo_locations"): [str],
                         Optional("cdn_geo_restriction_type"): str,
                         Optional("cdn_logging_bucket"): str,
                         Optional("cdn_logging_bucket_prefix"): str,
@@ -109,10 +107,10 @@ class PlatformConfigSchema:
                         Optional("enable_logging"): bool,
                         Optional("env_root"): str,
                         Optional("forwarded_values_forward"): str,
-                        Optional("forwarded_values_headers"): list,
+                        Optional("forwarded_values_headers"): [str],
                         Optional("forwarded_values_query_string"): bool,
                         Optional("origin_protocol_policy"): str,
-                        Optional("origin_ssl_protocols"): list,
+                        Optional("origin_ssl_protocols"): [str],
                         Optional("slack_alert_channel_alb_secret_rotation"): str,
                         Optional("viewer_certificate_minimum_protocol_version"): str,
                         Optional("viewer_certificate_ssl_support_method"): str,
@@ -127,14 +125,15 @@ class PlatformConfigSchema:
         }
 
     @staticmethod
-    def __codebase_pipelines_schema() -> list[dict]:
-        return [
-            {
-                "name": str,
+    def __codebase_pipelines_schema() -> dict:
+        return {
+            str: {
                 "repository": str,
+                Optional("slack_channel"): str,
+                Optional("requires_image_build"): bool,
                 Optional("additional_ecr_repository"): str,
                 Optional("deploy_repository_branch"): str,
-                "services": list[str],
+                "services": [{str: [str]}],
                 "pipelines": [
                     Or(
                         {
@@ -160,7 +159,7 @@ class PlatformConfigSchema:
                     ),
                 ],
             },
-        ]
+        }
 
     @staticmethod
     def __default_versions_schema() -> dict:

dbt_platform_helper/providers/terraform_manifest.py

@@ -0,0 +1,120 @@
+import json
+from datetime import datetime
+from importlib.metadata import version
+from pathlib import Path
+from typing import Callable
+
+import click
+
+from dbt_platform_helper.constants import SUPPORTED_AWS_PROVIDER_VERSION
+from dbt_platform_helper.constants import SUPPORTED_TERRAFORM_VERSION
+from dbt_platform_helper.providers.files import FileProvider
+
+
+class TerraformManifestProvider:
+    def __init__(
+        self, file_provider: FileProvider = FileProvider(), echo: Callable[[str], None] = click.echo
+    ):
+        self.file_provider = file_provider
+        self.echo = echo
+
+    def generate_codebase_pipeline_config(
+        self,
+        platform_config: dict,
+        terraform_platform_modules_version: str,
+        ecr_imports: dict[str, str],
+    ):
+        default_account = (
+            platform_config.get("environments", {})
+            .get("*", {})
+            .get("accounts", {})
+            .get("deploy", {})
+            .get("name")
+        )
+        terraform = {}
+        self._add_header(terraform)
+        self._add_locals(terraform)
+        self._add_provider(terraform, default_account)
+        self._add_backend(terraform, platform_config, default_account)
+        self._add_codebase_pipeline_module(terraform, terraform_platform_modules_version)
+        self._add_imports(terraform, ecr_imports)
+
+        message = self.file_provider.mkfile(
+            str(Path(".").absolute()),
+            "terraform/codebase-pipelines/main.tf.json",
+            json.dumps(terraform, indent=2),
+            True,
+        )
+        self.echo(message)
+
+    @staticmethod
+    def _add_header(terraform: dict):
+        time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        version_header = f"Generated by platform-helper {version('dbt-platform-helper')} / {time}."
+        warning = "WARNING: This is an autogenerated file, not for manual editing."
+        # The "//" key denotes a comment in terraform json.
+        terraform["//"] = f"{version_header} {warning}"
+
+    @staticmethod
+    def _add_locals(terraform: dict):
+        terraform["locals"] = {
+            "platform_config": '${yamldecode(file("../../platform-config.yml"))}',
+            "application": '${local.platform_config["application"]}',
+            "all_codebases": '${local.platform_config["codebase_pipelines"]}',
+            "environments": '${local.platform_config["environments"]}',
+        }
+
+    @staticmethod
+    def _add_provider(terraform: dict, default_account: str):
+        terraform["provider"] = {"aws": {}}
+        terraform["provider"]["aws"]["region"] = "eu-west-2"
+        terraform["provider"]["aws"]["profile"] = default_account
+        terraform["provider"]["aws"]["alias"] = default_account
+        terraform["provider"]["aws"]["shared_credentials_files"] = ["~/.aws/config"]
+
+    @staticmethod
+    def _add_backend(terraform: dict, platform_config: dict, default_account: str):
+        terraform["terraform"] = {
+            "required_version": SUPPORTED_TERRAFORM_VERSION,
+            "backend": {
+                "s3": {
+                    "bucket": f"terraform-platform-state-{default_account}",
+                    "key": f"tfstate/application/{platform_config['application']}-codebase-pipelines.tfstate",
+                    "region": "eu-west-2",
+                    "encrypt": True,
+                    "kms_key_id": f"alias/terraform-platform-state-s3-key-{default_account}",
+                    "dynamodb_table": f"terraform-platform-lockdb-{default_account}",
+                }
+            },
+            "required_providers": {
+                "aws": {"source": "hashicorp/aws", "version": SUPPORTED_AWS_PROVIDER_VERSION}
+            },
+        }
+
+    @staticmethod
+    def _add_codebase_pipeline_module(terraform: dict, terraform_platform_modules_version: str):
+        source = f"git::https://github.com/uktrade/terraform-platform-modules.git//codebase-pipelines?depth=1&ref={terraform_platform_modules_version}"
+        terraform["module"] = {
+            "codebase-pipelines": {
+                "source": source,
+                "for_each": "${local.all_codebases}",
+                "application": "${local.application}",
+                "codebase": "${each.key}",
+                "repository": "${each.value.repository}",
+                "additional_ecr_repository": '${lookup(each.value, "additional_ecr_repository", null)}',
+                "pipelines": "${each.value.pipelines}",
+                "services": "${each.value.services}",
+                "requires_image_build": '${lookup(each.value, "requires_image_build", true)}',
+                "slack_channel": '${lookup(each.value, "slack_channel", "/codebuild/slack_oauth_channel")}',
+                "env_config": "${local.environments}",
+            }
+        }
+
+    @staticmethod
+    def _add_imports(terraform: dict, ecr_imports: dict[str, str]):
+        if ecr_imports:
+            terraform["import"] = {
+                "for_each": "${%s}" % json.dumps(ecr_imports),
+                "id": "${each.value}",
+                "to": "module.codebase-pipelines[each.key].aws_ecr_repository.this",
+            }

dbt_platform_helper/providers/vpc.py

@@ -98,9 +98,4 @@ class VpcProvider:
 
         sec_groups = self._get_security_groups(app, env, vpc_id)
 
-        if not sec_groups:
-            raise SecurityGroupNotFoundException(
-                f"No matching security groups found in vpc '{vpc_name}'"
-            )
-
         return Vpc(vpc_id, public_subnets, private_subnets, sec_groups)

dbt_platform_helper/templates/environment-pipelines/main.tf

@@ -15,7 +15,7 @@ provider "aws" {
 }
 
 terraform {
-  required_version = "~> 1.8"
+  required_version = "{{ terraform_version }}"
   backend "s3" {
     bucket         = "terraform-platform-state-{{ aws_account }}"
     key            = "tfstate/application/{{ application }}-pipelines.tfstate"
@@ -27,7 +27,7 @@ terraform {
   required_providers {
     aws = {
       source  = "hashicorp/aws"
-      version = "~> 5"
+      version = "{{ aws_provider_version }}"
     }
   }
 }

dbt_platform_helper/templates/environments/main.tf

@@ -7,12 +7,12 @@ locals {
   args = {
     application    = "{{ application }}"
     services       = local.config["extensions"]
-    dns_account_id = local.env_config["{{ environment }}"]["accounts"]["dns"]["id"]
+    env_config     = local.env_config
   }
 }
 
 terraform {
-  required_version = "~> 1.8"
+  required_version = "{{ terraform_version }}"
   backend "s3" {
     bucket         = "terraform-platform-state-{{ config.accounts.deploy.name }}"
     key            = "tfstate/application/{{ application }}-{{ environment }}.tfstate"
@@ -24,7 +24,7 @@ terraform {
   required_providers {
     aws = {
       source  = "hashicorp/aws"
-      version = "~> 5"
+      version = "{{ aws_provider_version }}"
     }
   }
 }
@@ -34,7 +34,6 @@ module "extensions" {
 
   args        = local.args
   environment = "{{ environment }}"
-  vpc_name    = "{{ config.vpc }}"
 }
 
 /* 

dbt_platform_helper/utils/aws.py

@@ -18,6 +18,7 @@ from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.aws import CopilotCodebaseNotFoundException
 from dbt_platform_helper.providers.aws import ImageNotFoundException
 from dbt_platform_helper.providers.aws import LogGroupNotFoundException
+from dbt_platform_helper.providers.aws import RepositoryNotFoundException
 from dbt_platform_helper.providers.validation import ValidationException
 
 SSM_BASE_PATH = "/copilot/{app}/{env}/secrets/"
@@ -381,6 +382,11 @@ def start_build_extraction(codebuild_client, build_options):
     return response["build"]["arn"]
 
 
+def start_pipeline_and_return_execution_id(codepipeline_client, build_options):
+    response = codepipeline_client.start_pipeline_execution(**build_options)
+    return response["pipelineExecutionId"]
+
+
 # Todo: This should probably be in the AWS Copilot provider
 def check_codebase_exists(session: Session, application, codebase: str):
     try:
@@ -402,16 +408,16 @@ def check_codebase_exists(session: Session, application, codebase: str):
 
 def check_image_exists(session, application, codebase, commit):
     ecr_client = session.client("ecr")
+    repository = f"{application.name}/{codebase}"
     try:
         ecr_client.describe_images(
-            repositoryName=f"{application.name}/{codebase}",
+            repositoryName=repository,
             imageIds=[{"imageTag": f"commit-{commit}"}],
         )
-    except (
-        ecr_client.exceptions.RepositoryNotFoundException,
-        ecr_client.exceptions.ImageNotFoundException,
-    ):
+    except ecr_client.exceptions.ImageNotFoundException:
         raise ImageNotFoundException(commit)
+    except ecr_client.exceptions.RepositoryNotFoundException:
+        raise RepositoryNotFoundException(repository)
 
 
 def get_build_url_from_arn(build_arn: str) -> str:
@@ -423,6 +429,11 @@ def get_build_url_from_arn(build_arn: str) -> str:
     )
 
 
+def get_build_url_from_pipeline_execution_id(execution_id: str, pipeline_name: str) -> str:
+
+    return f"https://eu-west-2.console.aws.amazon.com/codesuite/codepipeline/pipelines/{pipeline_name}/executions/{execution_id}"
+
+
 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(