dbt-platform-helper 13.4.0__py3-none-any.whl → 14.0.0__py3-none-any.whl

dbt_platform_helper/domain/maintenance_page.py

@@ -48,7 +48,7 @@ class FailedToActivateMaintenancePageException(MaintenancePageException):
         return f"{super().__str__()}\n" f"Original exception: {self.orginal_exception}"
 
 
-# TODO should this be in its own provider, inside the VPC one, what logic is this sepcific too?
+# TODO: DBTP-1958: should this be in its own provider, inside the VPC one, what logic is this sepcific too?
 def get_env_ips(vpc: str, application_environment: Environment) -> List[str]:
     account_name = f"{application_environment.session.profile_name}-vpc"
     vpc_name = vpc if vpc else account_name
@@ -73,7 +73,7 @@ class MaintenancePage:
     ):
         self.application = application
         self.io = io
-        self.load_balancer_provider = load_balancer_provider  # TODO requires session from environment in application object which is only known during method execution
+        self.load_balancer_provider = load_balancer_provider  # TODO: DBTP-1962: requires session from environment in application object which is only known during method execution
         self.load_balancer: LoadBalancerProvider = None
         self.get_env_ips = get_env_ips
 
@@ -87,7 +87,7 @@ class MaintenancePage:
             raise LoadBalancedWebServiceNotFoundException(app.name)
         return services
 
-    # TODO: inject load balancer provider in activate method to avoid passing load balancer provider in init?
+    # TODO: DBTP-1962: inject load balancer provider in activate method to avoid passing load balancer provider in init?
     def activate(self, env: str, services: List[str], template: str, vpc: Union[str, None]):
 
         services = self._get_deployed_load_balanced_web_services(self.application, services)
@@ -229,44 +229,48 @@ class MaintenancePage:
                 f"\nUse a browser plugin to add `Bypass-Key` header with value {bypass_value} to your requests. For more detail, visit https://platform.readme.trade.gov.uk/next-steps/put-a-service-under-maintenance/",
             )
 
-            self.load_balancer.create_rule(
-                listener_arn=listener_arn,
-                priority=next(rule_priority),
-                conditions=[
+            unique_sorted_host_headers = sorted(
+                list(
                     {
-                        "Field": "path-pattern",
-                        "PathPatternConfig": {"Values": ["/*"]},
-                    },
-                    {
-                        "Field": "host-header",
-                        "HostHeaderConfig": {
-                            "Values": sorted(
-                                list(
-                                    {
-                                        value
-                                        for condition in maintenance_page_host_header_conditions
-                                        for value in condition["HostHeaderConfig"]["Values"]
-                                    }
-                                )
-                            )
-                        },
-                    },
-                ],
-                actions=[
-                    {
-                        "Type": "fixed-response",
-                        "FixedResponseConfig": {
-                            "StatusCode": "503",
-                            "ContentType": "text/html",
-                            "MessageBody": maintenance_page_content,
-                        },
+                        value
+                        for condition in maintenance_page_host_header_conditions
+                        for value in condition["HostHeaderConfig"]["Values"]
                     }
-                ],
-                tags=[
-                    {"Key": "name", "Value": "MaintenancePage"},
-                    {"Key": "type", "Value": template},
-                ],
+                )
             )
+
+            # Can only set 4 host headers per rule as listener rules have a max conditions of 5
+            for i in range(0, len(unique_sorted_host_headers), 4):
+                self.load_balancer.create_rule(
+                    listener_arn=listener_arn,
+                    priority=next(rule_priority),
+                    conditions=[
+                        {
+                            "Field": "path-pattern",
+                            "PathPatternConfig": {"Values": ["/*"]},
+                        },
+                        {
+                            "Field": "host-header",
+                            "HostHeaderConfig": {
+                                "Values": unique_sorted_host_headers[i : i + 4],
+                            },
+                        },
+                    ],
+                    actions=[
+                        {
+                            "Type": "fixed-response",
+                            "FixedResponseConfig": {
+                                "StatusCode": "503",
+                                "ContentType": "text/html",
+                                "MessageBody": maintenance_page_content,
+                            },
+                        }
+                    ],
+                    tags=[
+                        {"Key": "name", "Value": "MaintenancePage"},
+                        {"Key": "type", "Value": template},
+                    ],
+                )
         except Exception as e:
             self.__clean_up_maintenance_page_rules(listener_arn)
             raise FailedToActivateMaintenancePageException(

dbt_platform_helper/domain/notify.py

@@ -0,0 +1,64 @@
+from dbt_platform_helper.providers.slack_channel_notifier import SlackChannelNotifier
+from dbt_platform_helper.utils.arn_parser import ARN
+
+
+class Notify:
+    def __init__(self, notifier: SlackChannelNotifier):
+        self.notifier = notifier
+
+    def environment_progress(
+        self,
+        message: str,
+        build_arn: str = None,
+        repository: str = None,
+        commit_sha: str = None,
+        original_message_ref: str = None,
+    ):
+        context = []
+
+        if repository:
+            context.append(f"*Repository*: <https://github.com/{repository}|{repository}>")
+            if commit_sha:
+                context.append(
+                    f"*Revision*: <https://github.com/{repository}/commit/{commit_sha}|{commit_sha}>"
+                )
+
+        if build_arn:
+            context.append(f"<{get_build_url(build_arn)}|Build Logs>")
+
+        if original_message_ref:
+            return self.notifier.post_update(original_message_ref, message, context)
+        else:
+            return self.notifier.post_new(message, context)
+
+    def add_comment(
+        self,
+        original_message_ref: str,
+        message: str,
+        title: str,
+        reply_broadcast: bool,
+    ):
+        self.notifier.post_new(
+            message=message,
+            title=title,
+            context=[],
+            reply_broadcast=reply_broadcast,
+            thread_ref=original_message_ref,
+        )
+
+
+def get_build_url(build_arn: str):
+    try:
+        arn = ARN(build_arn)
+        url = (
+            "https://{region}.console.aws.amazon.com/codesuite/codebuild/{account}/projects/{"
+            "project}/build/{project}%3A{build_id}"
+        )
+        return url.format(
+            region=arn.region,
+            account=arn.account_id,
+            project=arn.project.replace("build/", ""),
+            build_id=arn.build_id,
+        )
+    except ValueError:
+        return ""

dbt_platform_helper/domain/pipelines.py

@@ -1,3 +1,4 @@
+import os
 from collections.abc import Callable
 from os import makedirs
 from pathlib import Path
@@ -5,6 +6,7 @@ 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 PLATFORM_HELPER_VERSION_OVERRIDE_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
@@ -14,9 +16,6 @@ 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.template import setup_templates
-from dbt_platform_helper.utils.tool_versioning import (
-    get_required_terraform_platform_modules_version,
-)
 
 
 class Pipelines:
@@ -29,6 +28,7 @@ class Pipelines:
         get_codestar_arn: Callable[[str], str],
         io: ClickIOProvider = ClickIOProvider(),
         file_provider: FileProvider = FileProvider(),
+        platform_helper_version_override: str = None,
     ):
         self.config_provider = config_provider
         self.get_git_remote = get_git_remote
@@ -37,8 +37,14 @@ class Pipelines:
         self.ecr_provider = ecr_provider
         self.io = io
         self.file_provider = file_provider
+        self.platform_helper_version_override = platform_helper_version_override or os.environ.get(
+            PLATFORM_HELPER_VERSION_OVERRIDE_KEY
+        )
 
-    def generate(self, cli_terraform_platform_modules_version: str, deploy_branch: str):
+    def generate(
+        self,
+        deploy_branch: str,
+    ):
         platform_config = self.config_provider.load_and_validate_platform_config()
 
         has_codebase_pipelines = CODEBASE_PIPELINES_KEY in platform_config
@@ -48,10 +54,6 @@ class Pipelines:
             self.io.warn("No pipelines defined: nothing to do.")
             return
 
-        platform_config_terraform_modules_default_version = platform_config.get(
-            "default_versions", {}
-        ).get("terraform-platform-modules", "")
-
         app_name = get_application_name()
 
         git_repo = self.get_git_remote()
@@ -67,12 +69,14 @@ 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,
+        platform_helper_version_for_template: str = platform_config.get("default_versions", {}).get(
+            "platform-helper"
         )
 
-        # TODO - this whole code block/if-statement can fall away once the deploy_repository is a required key.
+        if self.platform_helper_version_override:
+            platform_helper_version_for_template = self.platform_helper_version_override
+
+        # TODO: DBTP-1965: - this whole code block/if-statement can fall away once the deploy_repository is a required key.
         deploy_repository = ""
         if "deploy_repository" in platform_config.keys():
             deploy_repository = f"{platform_config['deploy_repository']}"
@@ -95,7 +99,7 @@ class Pipelines:
                     platform_config["application"],
                     deploy_repository,
                     account,
-                    terraform_platform_modules_version,
+                    platform_helper_version_for_template,
                     deploy_branch,
                 )
 
@@ -114,7 +118,7 @@ class Pipelines:
 
             self.terraform_manifest_provider.generate_codebase_pipeline_config(
                 platform_config,
-                terraform_platform_modules_version,
+                platform_helper_version_for_template,
                 ecrs_that_need_importing,
                 deploy_repository,
             )
@@ -129,7 +133,7 @@ class Pipelines:
         application: str,
         deploy_repository: str,
         aws_account: str,
-        terraform_platform_modules_version: str,
+        platform_helper_version: str,
         deploy_branch: str,
     ):
         env_pipeline_template = setup_templates().get_template("environment-pipelines/main.tf")
@@ -139,7 +143,7 @@ class Pipelines:
                 "application": application,
                 "deploy_repository": deploy_repository,
                 "aws_account": aws_account,
-                "terraform_platform_modules_version": terraform_platform_modules_version,
+                "platform_helper_version": platform_helper_version,
                 "deploy_branch": deploy_branch,
                 "terraform_version": SUPPORTED_TERRAFORM_VERSION,
                 "aws_provider_version": SUPPORTED_AWS_PROVIDER_VERSION,

dbt_platform_helper/domain/terraform_environment.py

@@ -1,9 +1,9 @@
+import os
+
+from dbt_platform_helper.constants import PLATFORM_HELPER_VERSION_OVERRIDE_KEY
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.terraform_manifest import TerraformManifestProvider
-from dbt_platform_helper.utils.tool_versioning import (
-    get_required_terraform_platform_modules_version,
-)
 
 
 class TerraformEnvironmentException(PlatformException):
@@ -20,12 +20,20 @@ class TerraformEnvironment:
         config_provider,
         manifest_provider: TerraformManifestProvider = None,
         io: ClickIOProvider = ClickIOProvider(),
+        platform_helper_version_override: str = None,
     ):
         self.io = io
         self.config_provider = config_provider
         self.manifest_provider = manifest_provider or TerraformManifestProvider()
+        self.platform_helper_version_override = platform_helper_version_override or os.environ.get(
+            PLATFORM_HELPER_VERSION_OVERRIDE_KEY
+        )
+
+    def generate(
+        self,
+        environment_name: str,
+    ):
 
-    def generate(self, environment_name, terraform_platform_modules_version_override=None):
         config = self.config_provider.get_enriched_config()
 
         if environment_name not in config.get("environments").keys():
@@ -33,14 +41,13 @@ class TerraformEnvironment:
                 f"cannot generate terraform for environment {environment_name}.  It does not exist in your configuration"
             )
 
-        platform_config_terraform_modules_default_version = config.get("default_versions", {}).get(
-            "terraform-platform-modules", ""
-        )
-        terraform_platform_modules_version = get_required_terraform_platform_modules_version(
-            terraform_platform_modules_version_override,
-            platform_config_terraform_modules_default_version,
+        platform_helper_version_for_template: str = config.get("default_versions", {}).get(
+            "platform-helper"
         )
 
+        if self.platform_helper_version_override:
+            platform_helper_version_for_template = self.platform_helper_version_override
+
         self.manifest_provider.generate_environment_config(
-            config, environment_name, terraform_platform_modules_version
+            config, environment_name, platform_helper_version_for_template
         )

dbt_platform_helper/domain/versioning.py

@@ -12,14 +12,11 @@ from dbt_platform_helper.providers.semantic_version import (
 from dbt_platform_helper.providers.semantic_version import SemanticVersion
 from dbt_platform_helper.providers.version import AWSCLIInstalledVersionProvider
 from dbt_platform_helper.providers.version import CopilotInstalledVersionProvider
-from dbt_platform_helper.providers.version import DeprecatedVersionFileVersionProvider
 from dbt_platform_helper.providers.version import GithubLatestVersionProvider
 from dbt_platform_helper.providers.version import InstalledVersionProvider
 from dbt_platform_helper.providers.version import PyPiLatestVersionProvider
 from dbt_platform_helper.providers.version import VersionProvider
-from dbt_platform_helper.providers.version_status import PlatformHelperVersionStatus
 from dbt_platform_helper.providers.version_status import VersionStatus
-from dbt_platform_helper.providers.yaml_file import YamlFileProvider
 
 
 def running_as_installed_package():
@@ -31,24 +28,20 @@ def skip_version_checks():
 
 
 class PlatformHelperVersionNotFoundException(PlatformException):
-    def __init__(self):
-        super().__init__(f"""Platform helper version could not be resolved.""")
+    def __init__(self, message=None):
+        super().__init__(message or "Platform helper version could not be resolved.")
 
 
 class PlatformHelperVersioning:
     def __init__(
         self,
         io: ClickIOProvider = ClickIOProvider(),
-        version_file_version_provider: DeprecatedVersionFileVersionProvider = DeprecatedVersionFileVersionProvider(
-            YamlFileProvider
-        ),
         config_provider: ConfigProvider = ConfigProvider(),
         latest_version_provider: VersionProvider = PyPiLatestVersionProvider,
         installed_version_provider: InstalledVersionProvider = InstalledVersionProvider(),
         skip_versioning_checks: bool = None,
     ):
         self.io = io
-        self.version_file_version_provider = version_file_version_provider
         self.config_provider = config_provider
         self.latest_version_provider = latest_version_provider
         self.installed_version_provider = installed_version_provider
@@ -56,10 +49,9 @@ class PlatformHelperVersioning:
             skip_versioning_checks if skip_versioning_checks is not None else skip_version_checks()
         )
 
-    def get_required_version(self, pipeline=None):
-        version_status = self._get_version_status()
-        self.io.process_messages(version_status.validate())
-        required_version = self._resolve_required_version(pipeline, version_status)
+    def get_required_version(self):
+        platform_config = self.config_provider.load_and_validate_platform_config()
+        required_version = platform_config.get("default_versions", {}).get("platform-helper")
         self.io.info(required_version)
         return required_version
 
@@ -68,25 +60,24 @@ class PlatformHelperVersioning:
         if self.skip_versioning_checks:
             return
 
-        version_status = self._get_version_status()
-        self.io.process_messages(version_status.validate())
+        version_status = self.get_version_status()
+        required_version = self.get_required_version()
 
-        required_version = SemanticVersion.from_string(
-            self._resolve_required_version(version_status=version_status)
-        )
+        if SemanticVersion.is_semantic_version(required_version):
+            required_version_semver = SemanticVersion.from_string(required_version)
 
-        if not version_status.installed == required_version:
-            message = (
-                f"WARNING: You are running platform-helper v{version_status.installed} against "
-                f"v{required_version} specified for the project."
-            )
-            self.io.warn(message)
+            if not version_status.installed == required_version_semver:
+                message = (
+                    f"WARNING: You are running platform-helper v{version_status.installed} against "
+                    f"v{required_version_semver} specified for the project."
+                )
+                self.io.warn(message)
 
     def check_if_needs_update(self):
         if self.skip_versioning_checks:
             return
 
-        version_status = self._get_version_status(include_project_versions=False)
+        version_status = self.get_version_status()
 
         message = (
             f"You are running platform-helper v{version_status.installed}, upgrade to "
@@ -101,65 +92,14 @@ class PlatformHelperVersioning:
         except IncompatibleMinorVersionException:
             self.io.warn(message)
 
-    def _get_version_status(
-        self,
-        include_project_versions: bool = True,
-    ) -> PlatformHelperVersionStatus:
+    def get_version_status(self) -> VersionStatus:
         locally_installed_version = self.installed_version_provider.get_semantic_version(
             "dbt-platform-helper"
         )
 
         latest_release = self.latest_version_provider.get_semantic_version("dbt-platform-helper")
 
-        if not include_project_versions:
-            return PlatformHelperVersionStatus(
-                installed=locally_installed_version,
-                latest=latest_release,
-            )
-
-        platform_config_default, pipeline_overrides = None, {}
-
-        platform_config = self.config_provider.load_unvalidated_config_file()
-
-        if platform_config:
-            platform_config_default = SemanticVersion.from_string(
-                platform_config.get("default_versions", {}).get("platform-helper")
-            )
-
-            pipeline_overrides = {
-                name: pipeline.get("versions", {}).get("platform-helper")
-                for name, pipeline in platform_config.get("environment_pipelines", {}).items()
-                if pipeline.get("versions", {}).get("platform-helper")
-            }
-        out = PlatformHelperVersionStatus(
-            installed=locally_installed_version,
-            latest=latest_release,
-            deprecated_version_file=self.version_file_version_provider.get_semantic_version(),
-            platform_config_default=platform_config_default,
-            pipeline_overrides=pipeline_overrides,
-        )
-
-        return out
-
-    def _resolve_required_version(
-        self, pipeline: str = None, version_status: PlatformHelperVersionStatus = None
-    ) -> str:
-        pipeline_version = version_status.pipeline_overrides.get(pipeline)
-        version_precedence = [
-            pipeline_version,
-            version_status.platform_config_default,
-            version_status.deprecated_version_file,
-        ]
-        non_null_version_precedence = [
-            f"{v}" if isinstance(v, SemanticVersion) else v for v in version_precedence if v
-        ]
-
-        out = non_null_version_precedence[0] if non_null_version_precedence else None
-
-        if not out:
-            raise PlatformHelperVersionNotFoundException
-
-        return out
+        return VersionStatus(installed=locally_installed_version, latest=latest_release)
 
 
 class AWSVersioning:

dbt_platform_helper/providers/aws/exceptions.py

@@ -29,7 +29,7 @@ class LogGroupNotFoundException(AWSException):
         super().__init__(f"""No log group called "{log_group_name}".""")
 
 
-# Todo: This should probably be in the AWS Copilot provider, but was causing circular import when we tried it pre refactoring the utils/aws.py
+# TODO: DBTP-1976: This should probably be in the AWS Copilot provider, but was causing circular import when we tried it pre refactoring the utils/aws.py
 class CopilotCodebaseNotFoundException(PlatformException):
     def __init__(self, codebase: str):
         super().__init__(

dbt_platform_helper/providers/cloudformation.py

@@ -8,7 +8,7 @@ from dbt_platform_helper.platform_exception import PlatformException
 
 
 class CloudFormation:
-    # TODO add handling for optional client parameters to handle case of calling boto API with None
+    # TODO: DBTP-1966: add handling for optional client parameters to handle case of calling boto API with None
     def __init__(self, cloudformation_client, iam_client=None, ssm_client=None):
         self.cloudformation_client = cloudformation_client
         self.iam_client = iam_client