dbt-platform-helper 13.1.0__py3-none-any.whl → 15.16.0__py3-none-any.whl

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/schema_migrations/schema_v0_to_v1_migration.py

@@ -0,0 +1,43 @@
+from copy import deepcopy
+
+
+class SchemaV0ToV1Migration:
+    def from_version(self) -> int:
+        return 0
+
+    def migrate(self, platform_config: dict) -> dict:
+        migrated_config = deepcopy(platform_config)
+
+        self._remove_terraform_platform_modules_default_version(migrated_config)
+        self._remove_versions_from_env_config(migrated_config)
+        self._remove_to_account_and_from_account_from_database_copy(migrated_config)
+        self._remove_pipeline_platform_helper_override(migrated_config)
+
+        return migrated_config
+
+    def _remove_versions_from_env_config(self, migrated_config: dict) -> None:
+        for env_name, env in migrated_config.get("environments", {}).items():
+            if env and "versions" in env:
+                del env["versions"]
+
+    def _remove_terraform_platform_modules_default_version(self, migrated_config: dict) -> None:
+        if "default_versions" in migrated_config:
+            default_versions = migrated_config["default_versions"]
+            if "terraform-platform-modules" in default_versions:
+                del default_versions["terraform-platform-modules"]
+
+    def _remove_to_account_and_from_account_from_database_copy(self, migrated_config: dict) -> None:
+        for extension_name, extension in migrated_config.get("extensions", {}).items():
+            if extension.get("type") == "postgres" and "database_copy" in extension:
+                for database_copy_block in extension["database_copy"]:
+                    if "from_account" in database_copy_block:
+                        del database_copy_block["from_account"]
+                    if "to_account" in database_copy_block:
+                        del database_copy_block["to_account"]
+
+    def _remove_pipeline_platform_helper_override(self, migrated_config: dict) -> None:
+        for pipeline_name, pipeline_config in migrated_config.get(
+            "environment_pipelines", {}
+        ).items():
+            if "versions" in pipeline_config:
+                del pipeline_config["versions"]

dbt_platform_helper/providers/schema_migrator.py

@@ -0,0 +1,77 @@
+from collections import Counter
+from collections import OrderedDict
+from copy import deepcopy
+from typing import Protocol
+
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.schema_migrations.schema_v0_to_v1_migration import (
+    SchemaV0ToV1Migration,
+)
+from dbt_platform_helper.providers.version import InstalledVersionProvider
+
+
+class InvalidMigrationConfigurationException(PlatformException):
+    pass
+
+
+class SchemaMigrationProtocol(Protocol):
+    def from_version(self) -> int: ...
+
+    def migrate(self, platform_config: dict) -> dict: ...
+
+
+# TODO: Possibly get this programmatically?
+ALL_MIGRATIONS = [SchemaV0ToV1Migration()]
+
+
+class Migrator:
+    def __init__(
+        self,
+        migrations: list[SchemaMigrationProtocol],
+        installed_version_provider: InstalledVersionProvider = InstalledVersionProvider,
+        io_provider: ClickIOProvider = ClickIOProvider(),
+    ):
+        self.migrations = sorted(migrations, key=lambda m: m.from_version())
+        self.installed_version_provider = installed_version_provider
+        self.io_provider = io_provider
+        from_version_counts = Counter([migration.from_version() for migration in self.migrations])
+        duplicate_from_versions = [count for count in from_version_counts.values() if count > 1]
+
+        if duplicate_from_versions:
+            raise InvalidMigrationConfigurationException(
+                "`from_version` parameters must be unique amongst migrations"
+            )
+
+    def migrate(self, platform_config: dict) -> dict:
+        out = OrderedDict(deepcopy(platform_config))
+        if "schema_version" not in out:
+            out["schema_version"] = 0
+
+        if "default_versions" in out:
+            out.move_to_end("default_versions", last=False)
+        if "schema_version" in out:
+            out.move_to_end("schema_version", last=False)
+        if "application" in out:
+            out.move_to_end("application", last=False)
+
+        for migration in self.migrations:
+            migration_can_be_applied = migration.from_version() == out["schema_version"]
+            if migration_can_be_applied:
+                out = migration.migrate(out)
+                schema_version = out["schema_version"]
+                self.io_provider.info(
+                    f"Migrating from platform config schema version {schema_version} to version {schema_version + 1}"
+                )
+                out["schema_version"] += 1
+
+        if "default_versions" not in out:
+            out["default_versions"] = {}
+
+        out["default_versions"]["platform-helper"] = str(
+            self.installed_version_provider.get_semantic_version("dbt-platform-helper")
+        )
+
+        self.io_provider.info("\nMigration complete")
+
+        return dict(out)

dbt_platform_helper/providers/secrets.py

@@ -41,7 +41,7 @@ class Secrets:
 
         raise SecretNotFoundException(secret_name)
 
-    # Todo: This probably does not belong in the secrets provider. When it moves, take the Todoed exceptions from below
+    # TODO: DBTP-1946: This probably does not belong in the secrets provider. When it moves, take the Todoed exceptions from below
     def get_addon_type(self, addon_name: str) -> str:
         addon_type = None
         try:
@@ -82,18 +82,18 @@ class Secrets:
         return addon_name.replace("-", "_").upper()
 
 
-# Todo: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
+# TODO: DBTP-1946: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
 class AddonException(PlatformException):
     pass
 
 
-# Todo: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
+# TODO: DBTP-1946: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
 class AddonNotFoundException(AddonException):
     def __init__(self, addon_name: str):
         super().__init__(f"""Addon "{addon_name}" does not exist.""")
 
 
-# Todo: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
+# TODO: DBTP-1946: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
 class AddonTypeMissingFromConfigException(AddonException):
     def __init__(self, addon_name: str):
         super().__init__(
@@ -101,7 +101,7 @@ class AddonTypeMissingFromConfigException(AddonException):
         )
 
 
-# Todo: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
+# TODO: DBTP-1946: This probably does not belong in the secrets provider. Move it when we find a better home for get_addon_type()
 class InvalidAddonTypeException(AddonException):
     def __init__(self, addon_type):
         self.addon_type = addon_type

dbt_platform_helper/providers/slack_channel_notifier.py

@@ -0,0 +1,62 @@
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
+from slack_sdk.models import blocks
+
+from dbt_platform_helper.platform_exception import PlatformException
+
+
+class SlackChannelNotifierException(PlatformException):
+    pass
+
+
+class SlackChannelNotifier:
+    def __init__(self, slack_token: str, slack_channel_id: str):
+        self.client = WebClient(slack_token)
+        self.slack_channel_id = slack_channel_id
+
+    def post_update(self, message_ref, message, context=None):
+        args = {
+            "channel": self.slack_channel_id,
+            "blocks": self._build_message_blocks(message, context),
+            "text": message,
+            "unfurl_links": False,
+            "unfurl_media": False,
+        }
+
+        try:
+            response = self.client.chat_update(ts=message_ref, **args)
+            return response["ts"]
+        except SlackApiError as e:
+            raise SlackChannelNotifierException(f"Slack notification unsuccessful: {e}")
+
+    def post_new(self, message, context=None, title=None, reply_broadcast=None, thread_ref=None):
+        args = {
+            "channel": self.slack_channel_id,
+            "blocks": self._build_message_blocks(message, context),
+            "text": title if title else message,
+            "reply_broadcast": reply_broadcast,
+            "unfurl_links": False,
+            "unfurl_media": False,
+            "thread_ts": thread_ref,
+        }
+
+        try:
+            response = self.client.chat_postMessage(ts=None, **args)
+            return response["ts"]
+        except SlackApiError as e:
+            raise SlackChannelNotifierException(f"Slack notification unsuccessful: {e}")
+
+    def _build_message_blocks(self, message, context):
+        message_blocks = [
+            blocks.SectionBlock(
+                text=blocks.TextObject(type="mrkdwn", text=message),
+            ),
+        ]
+
+        if context:
+            message_blocks.append(
+                blocks.ContextBlock(
+                    elements=[blocks.TextObject(type="mrkdwn", text=element) for element in context]
+                )
+            )
+        return message_blocks

dbt_platform_helper/providers/terraform_manifest.py

@@ -3,6 +3,7 @@ from datetime import datetime
 from importlib.metadata import version
 from pathlib import Path
 
+from dbt_platform_helper.constants import EXTENSIONS_MODULE_PATH
 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
@@ -17,23 +18,98 @@ class TerraformManifestProvider:
         self.file_provider = file_provider
         self.io = io
 
+    def generate_service_config(
+        self,
+        config_object,
+        environment,
+        platform_helper_version: str,
+        platform_config,
+        module_source_override: str = None,
+    ):
+
+        service_dir = f"terraform/services/{environment}/{config_object.name}"
+        platform_config = ConfigProvider.apply_environment_defaults(platform_config)
+        account = self._get_account_for_env(environment, platform_config)
+        deploy_to_account_id = self._get_account_id_for_account(account, platform_config)
+        application_name = platform_config["application"]
+
+        terraform = {}
+        self._add_header(terraform)
+
+        self._add_service_locals(terraform, environment)
+
+        self._add_provider(terraform, account, deploy_to_account_id)
+        self._add_backend(
+            terraform,
+            platform_config,
+            account,
+            f"tfstate/application/{application_name}/services/{environment}/{config_object.name}.tfstate",
+        )
+
+        self._add_service_module(terraform, platform_helper_version, module_source_override)
+
+        self._write_terraform_json(terraform, service_dir)
+
+    def _add_service_locals(self, terraform, environment):
+        terraform["locals"] = {
+            "environment": environment,
+            "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(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")}',
+            "non_copilot_service_deployment_mode": '${local.service_deployment_mode == "dual-deploy-copilot-traffic" || local.service_deployment_mode == "dual-deploy-platform-traffic" || local.service_deployment_mode == "platform" ? 1 : 0}',
+            "custom_iam_policy_path": '${abspath(format("%s/../../../../services/%s/custom-iam-policy/%s.yml", path.module, local.service_config.name, local.environment))}',
+            "custom_iam_policy_json": "${fileexists(local.custom_iam_policy_path) ? jsonencode(yamldecode(file(local.custom_iam_policy_path))) : null}",
+        }
+
+    def _add_service_module(
+        self, terraform: dict, platform_helper_version: str, module_source_override: str = None
+    ):
+        source = (
+            module_source_override
+            or f"git::git@github.com:uktrade/platform-tools.git//terraform/ecs-service?depth=1&ref={platform_helper_version}"
+        )
+        terraform["module"] = {
+            "ecs-service": {
+                "source": source,
+                "count": "${local.non_copilot_service_deployment_mode}",
+                "application": "${local.application}",
+                "environment": "${local.environment}",
+                "service_config": "${local.service_config}",
+                "env_config": "${local.env_config}",
+                "platform_extensions": '${local.platform_config["extensions"]}',
+                "custom_iam_policy_json": "${local.custom_iam_policy_json}",
+            }
+        }
+
     def generate_codebase_pipeline_config(
         self,
         platform_config: dict,
-        terraform_platform_modules_version: str,
+        platform_helper_version: str,
         ecr_imports: dict[str, str],
         deploy_repository: str,
+        module_source: str,
     ):
         default_account = self._get_account_for_env("*", platform_config)
+        deploy_to_account_id = self._get_account_id_for_account(default_account, platform_config)
         state_key_suffix = f"{platform_config['application']}-codebase-pipelines"
 
         terraform = {}
         self._add_header(terraform)
         self._add_codebase_pipeline_locals(terraform)
-        self._add_provider(terraform, default_account)
-        self._add_backend(terraform, platform_config, default_account, state_key_suffix)
+        self._add_provider(terraform, default_account, deploy_to_account_id)
+        self._add_backend(
+            terraform,
+            platform_config,
+            default_account,
+            f"tfstate/application/{state_key_suffix}.tfstate",
+        )
         self._add_codebase_pipeline_module(
-            terraform, terraform_platform_modules_version, deploy_repository
+            terraform, platform_helper_version, deploy_repository, module_source
         )
         self._add_imports(terraform, ecr_imports)
         self._write_terraform_json(terraform, "terraform/codebase-pipelines")
@@ -42,7 +118,8 @@ class TerraformManifestProvider:
         self,
         platform_config: dict,
         env: str,
-        terraform_platform_modules_version: str,
+        platform_helper_version: str,
+        module_source_override: str = None,
     ):
         platform_config = ConfigProvider.apply_environment_defaults(platform_config)
         account = self._get_account_for_env(env, platform_config)
@@ -54,8 +131,10 @@ class TerraformManifestProvider:
         terraform = {}
         self._add_header(terraform)
         self._add_environment_locals(terraform, application_name)
-        self._add_backend(terraform, platform_config, account, state_key_suffix)
-        self._add_extensions_module(terraform, terraform_platform_modules_version, env)
+        self._add_backend(
+            terraform, platform_config, account, f"tfstate/application/{state_key_suffix}.tfstate"
+        )
+        self._add_extensions_module(terraform, platform_helper_version, env, module_source_override)
         self._add_moved(terraform, platform_config)
         self._ensure_no_hcl_manifest_file(env_dir)
         self._write_terraform_json(terraform, env_dir)
@@ -71,6 +150,16 @@ class TerraformManifestProvider:
         )
         return account
 
+    @staticmethod
+    def _get_account_id_for_account(account_name, platform_config):
+        environment_config = platform_config["environments"]
+        account_id_lookup = {
+            env["accounts"]["deploy"]["name"]: env["accounts"]["deploy"]["id"]
+            for env in environment_config.values()
+            if env is not None and "accounts" in env and "deploy" in env["accounts"]
+        }
+        return account_id_lookup.get(account_name)
+
     @staticmethod
     def _add_header(terraform: dict):
         time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@@ -89,21 +178,20 @@ class TerraformManifestProvider:
         }
 
     @staticmethod
-    def _add_provider(terraform: dict, default_account: str):
+    def _add_provider(terraform: dict, deploy_to_account: str, deploy_to_account_id: 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"]
+        terraform["provider"]["aws"]["profile"] = deploy_to_account
+        terraform["provider"]["aws"]["allowed_account_ids"] = [deploy_to_account_id]
 
     @staticmethod
-    def _add_backend(terraform: dict, platform_config: dict, account: str, state_key_suffix: str):
+    def _add_backend(terraform: dict, platform_config: dict, account: str, state_key: str):
         terraform["terraform"] = {
             "required_version": SUPPORTED_TERRAFORM_VERSION,
             "backend": {
                 "s3": {
                     "bucket": f"terraform-platform-state-{account}",
-                    "key": f"tfstate/application/{state_key_suffix}.tfstate",
+                    "key": state_key,
                     "region": "eu-west-2",
                     "encrypt": True,
                     "kms_key_id": f"alias/terraform-platform-state-s3-key-{account}",
@@ -117,9 +205,12 @@ class TerraformManifestProvider:
 
     @staticmethod
     def _add_codebase_pipeline_module(
-        terraform: dict, terraform_platform_modules_version: str, deploy_repository: str
+        terraform: dict,
+        platform_helper_version: str,
+        deploy_repository: str,
+        module_source: str,
     ):
-        source = f"git::https://github.com/uktrade/terraform-platform-modules.git//codebase-pipelines?depth=1&ref={terraform_platform_modules_version}"
+        source = module_source
         terraform["module"] = {
             "codebase-pipelines": {
                 "source": source,
@@ -128,20 +219,30 @@ class TerraformManifestProvider:
                 "codebase": "${each.key}",
                 "repository": "${each.value.repository}",
                 "deploy_repository": f"{deploy_repository}",
+                "deploy_repository_branch": '${lookup(each.value, "deploy_repository_branch", "main")}',
                 "additional_ecr_repository": '${lookup(each.value, "additional_ecr_repository", null)}',
+                "cache_invalidation": '${lookup(each.value, "cache_invalidation", null)}',
                 "pipelines": '${lookup(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}",
+                "platform_tools_version": f"{platform_helper_version}",
             }
         }
 
     @staticmethod
-    def _add_extensions_module(terraform: dict, terraform_platform_modules_version: str, env: str):
-        source = f"git::https://github.com/uktrade/terraform-platform-modules.git//extensions?depth=1&ref={terraform_platform_modules_version}"
+    def _add_extensions_module(
+        terraform: dict, platform_helper_version: str, env: str, module_source_override: str = None
+    ):
+        source = module_source_override or f"{EXTENSIONS_MODULE_PATH}{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
@@ -164,6 +265,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
@@ -204,7 +306,7 @@ class TerraformManifestProvider:
 
     def _write_terraform_json(self, terraform: dict, env_dir: str):
         message = self.file_provider.mkfile(
-            str(Path(env_dir).absolute()),
+            str(Path(env_dir)),
             "main.tf.json",
             json.dumps(terraform, indent=2),
             True,

dbt_platform_helper/providers/version.py

@@ -1,36 +1,119 @@
+import re
+import subprocess
 from abc import ABC
+from abc import abstractmethod
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version
+from typing import Union
 
-import requests
+from requests import Session
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
 
-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.io import ClickIOProvider
 
 
-class VersionProvider(ABC):
+def set_up_retry():
+    session = Session()
+    retries = Retry(total=5, backoff_factor=0.1, status_forcelist=[403, 500, 502, 503, 504])
+    session.mount("https://", HTTPAdapter(max_retries=retries))
+    return session
+
+
+class InstalledVersionProviderException(PlatformException):
     pass
 
 
-# TODO add timeouts and exception handling for requests
-# TODO Alternatively use the gitpython package?
-class GithubVersionProvider(VersionProvider):
+class InstalledToolNotFoundException(InstalledVersionProviderException):
+    def __init__(
+        self,
+        tool_name: str,
+    ):
+        super().__init__(f"Package '{tool_name}' not found.")
+
+
+class VersionProvider(ABC):
+    @abstractmethod
+    def get_semantic_version() -> SemanticVersion:
+        raise NotImplementedError("Must be implemented in subclasses")
+
+
+class InstalledVersionProvider:
+    @staticmethod
+    def get_semantic_version(tool_name: str) -> SemanticVersion:
+        try:
+            return SemanticVersion.from_string(version(tool_name))
+
+        except PackageNotFoundError:
+            raise InstalledToolNotFoundException(tool_name)
+
+
+class GithubLatestVersionProvider(VersionProvider):
     @staticmethod
-    def get_latest_version(repo_name: str, tags: bool = False) -> SemanticVersion:
-        if tags:
-            tags_list = requests.get(f"https://api.github.com/repos/{repo_name}/tags").json()
-            versions = [SemanticVersion.from_string(v["name"]) for v in tags_list]
-            versions.sort(reverse=True)
-            return versions[0]
+    def get_semantic_version(
+        repo_name: str, tags: bool = False, request_session=set_up_retry(), io=ClickIOProvider()
+    ) -> Union[SemanticVersion, None]:
+
+        semantic_version = None
+        try:
+            if tags:
+                response = request_session.get(f"https://api.github.com/repos/{repo_name}/tags")
+
+                versions = [SemanticVersion.from_string(v["name"]) for v in response.json()]
+                versions.sort(reverse=True)
+                semantic_version = versions[0]
+            else:
+                package_info = request_session.get(
+                    f"https://api.github.com/repos/{repo_name}/releases/latest"
+                ).json()
+                semantic_version = SemanticVersion.from_string(package_info["tag_name"])
+        except Exception as e:
+            io.error(f"Exception occured when calling Github with:\n{str(e)}")
 
-        package_info = requests.get(
-            f"https://api.github.com/repos/{repo_name}/releases/latest"
-        ).json()
-        return SemanticVersion.from_string(package_info["tag_name"])
+        return semantic_version
+
+
+class PyPiLatestVersionProvider(VersionProvider):
+    @staticmethod
+    def get_semantic_version(
+        project_name: str, request_session=set_up_retry(), io=ClickIOProvider()
+    ) -> Union[SemanticVersion, None]:
+        semantic_version = None
+        try:
+            package_info = request_session.get(f"https://pypi.org/pypi/{project_name}/json").json()
+            released_versions = package_info["releases"].keys()
+            parsed_released_versions = [SemanticVersion.from_string(v) for v in released_versions]
+            parsed_released_versions.sort(reverse=True)
+            semantic_version = parsed_released_versions[0]
+        except Exception as e:
+            io.error(f"Exception occured when calling PyPi with:\n{str(e)}")
+        return semantic_version
 
 
-class PyPiVersionProvider(VersionProvider):
+class AWSCLIInstalledVersionProvider(VersionProvider):
     @staticmethod
-    def get_latest_version(project_name: str) -> SemanticVersion:
-        package_info = requests.get(f"https://pypi.org/pypi/{project_name}/json").json()
-        released_versions = package_info["releases"].keys()
-        parsed_released_versions = [SemanticVersion.from_string(v) for v in released_versions]
-        parsed_released_versions.sort(reverse=True)
-        return parsed_released_versions[0]
+    def get_semantic_version() -> Union[SemanticVersion, None]:
+        installed_aws_version = None
+        try:
+            response = subprocess.run("aws --version", capture_output=True, shell=True)
+            matched = re.match(r"aws-cli/([0-9.]+)", response.stdout.decode("utf8"))
+            installed_aws_version = matched.group(1)
+        except (ValueError, AttributeError):
+            pass
+        return SemanticVersion.from_string(installed_aws_version)
+
+
+class CopilotInstalledVersionProvider(VersionProvider):
+    @staticmethod
+    def get_semantic_version() -> Union[SemanticVersion, None]:
+        copilot_version = None
+
+        try:
+            response = subprocess.run("copilot --version", capture_output=True, shell=True)
+            [copilot_version] = re.findall(r"[0-9.]+", response.stdout.decode("utf8"))
+        except ValueError:
+            pass
+
+        return SemanticVersion.from_string(copilot_version)

dbt_platform_helper/providers/version_status.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+
+from dbt_platform_helper.entities.semantic_version import SemanticVersion
+from dbt_platform_helper.platform_exception import PlatformException
+
+
+class UnsupportedVersionException(PlatformException):
+    def __init__(self, version: str):
+        super().__init__(
+            f"""Platform-helper version {version} is not compatible with platform-helper. Please install version platform-helper version 14 or later."""
+        )
+
+
+@dataclass
+class VersionStatus:
+    installed: SemanticVersion = None
+    latest: SemanticVersion = None
+
+    def __str__(self):
+        attrs = {
+            key: value for key, value in vars(self).items() if isinstance(value, SemanticVersion)
+        }
+        attrs_str = ", ".join(f"{key}: {value}" for key, value in attrs.items())
+        return f"{self.__class__.__name__}: {attrs_str}"
+
+    def is_outdated(self):
+        return self.installed != self.latest