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

dbt_platform_helper/{providers → entities}/platform_config_schema.py

@@ -8,15 +8,22 @@ from schema import Regex
 from schema import Schema
 from schema import SchemaError
 
+from dbt_platform_helper.constants import PLATFORM_CONFIG_SCHEMA_VERSION
+from dbt_platform_helper.domain.plans import PlanLoader
+
+plan_manager = PlanLoader()
+plan_manager.load()
+
 
 class PlatformConfigSchema:
     @staticmethod
     def schema() -> Schema:
         return Schema(
             {
+                "schema_version": PLATFORM_CONFIG_SCHEMA_VERSION,
                 "application": str,
                 Optional("deploy_repository"): str,
-                Optional("default_versions"): PlatformConfigSchema.__default_versions_schema(),
+                "default_versions": PlatformConfigSchema.__default_versions_schema(),
                 Optional("environments"): PlatformConfigSchema.__environments_schema(),
                 Optional("codebase_pipelines"): PlatformConfigSchema.__codebase_pipelines_schema(),
                 Optional(
@@ -28,6 +35,7 @@ class PlatformConfigSchema:
                         PlatformConfigSchema.__monitoring_schema(),
                         PlatformConfigSchema.__opensearch_schema(),
                         PlatformConfigSchema.__postgres_schema(),
+                        PlatformConfigSchema.__datadog_schema(),
                         PlatformConfigSchema.__prometheus_policy_schema(),
                         PlatformConfigSchema.__redis_schema(),
                         PlatformConfigSchema.__s3_bucket_schema(),
@@ -48,12 +56,13 @@ class PlatformConfigSchema:
             "postgres": Schema(PlatformConfigSchema.__postgres_schema()),
             "prometheus-policy": Schema(PlatformConfigSchema.__prometheus_policy_schema()),
             "redis": Schema(PlatformConfigSchema.__redis_schema()),
+            "datadog": Schema(PlatformConfigSchema.__datadog_schema()),
             "s3": Schema(PlatformConfigSchema.__s3_bucket_schema()),
             "s3-policy": Schema(PlatformConfigSchema.__s3_bucket_policy_schema()),
             "subscription-filter": PlatformConfigSchema.__no_configuration_required_schema(
                 "subscription-filter"
             ),
-            # Todo: The next three are no longer relevant. Remove them.
+            # TODO: DBTP-1943: The next three are no longer relevant. Remove them.
             "monitoring": Schema(PlatformConfigSchema.__monitoring_schema()),
             "vpc": PlatformConfigSchema.__no_configuration_required_schema("vpc"),
             "xray": PlatformConfigSchema.__no_configuration_required_schema("xray"),
@@ -105,7 +114,6 @@ class PlatformConfigSchema:
                         Optional("default_waf"): str,
                         Optional("domain_prefix"): str,
                         Optional("enable_logging"): bool,
-                        Optional("env_root"): str,
                         Optional("forwarded_values_forward"): str,
                         Optional("forwarded_values_headers"): [str],
                         Optional("forwarded_values_query_string"): bool,
@@ -143,7 +151,7 @@ class PlatformConfigSchema:
                                 {
                                     "name": str,
                                     Optional("requires_approval"): bool,
-                                }
+                                },
                             ],
                         },
                         {
@@ -158,22 +166,24 @@ class PlatformConfigSchema:
                         },
                     ),
                 ],
+                Optional("cache_invalidation"): {
+                    "domains": PlatformConfigSchema.__cache_invalidation_domains_schema(),
+                },
             },
         }
 
+    @staticmethod
+    def __cache_invalidation_domains_schema() -> dict:
+        return {str: {"paths": [str], "environment": str}}
+
     @staticmethod
     def __default_versions_schema() -> dict:
         return {
-            Optional("terraform-platform-modules"): str,
-            Optional("platform-helper"): str,
+            "platform-helper": str,
         }
 
     @staticmethod
     def __environments_schema() -> dict:
-        _valid_environment_specific_version_overrides = {
-            Optional("terraform-platform-modules"): str,
-        }
-
         return {
             str: Or(
                 None,
@@ -188,10 +198,15 @@ class PlatformConfigSchema:
                             "id": str,
                         },
                     },
-                    # Todo: requires_approval is no longer relevant since we don't have AWS Copilot manage environment pipelines
+                    # TODO: DBTP-1943: requires_approval is no longer relevant since we don't have AWS Copilot manage environment pipelines
                     Optional("requires_approval"): bool,
-                    Optional("versions"): _valid_environment_specific_version_overrides,
                     Optional("vpc"): str,
+                    Optional("service-deployment-mode"): Or(
+                        "copilot",
+                        "dual-deploy-copilot-traffic",
+                        "dual-deploy-platform-traffic",
+                        "platform",
+                    ),
                 },
             )
         }
@@ -248,18 +263,8 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __opensearch_schema() -> dict:
-        # Todo: Move to OpenSearch provider?
-        _valid_opensearch_plans = Or(
-            "tiny",
-            "small",
-            "small-ha",
-            "medium",
-            "medium-ha",
-            "large",
-            "large-ha",
-            "x-large",
-            "x-large-ha",
-        )
+        # TODO: DBTP-1943: Move to OpenSearch provider?
+        _valid_opensearch_plans = Or(*plan_manager.get_plan_names("opensearch"))
 
         return {
             "type": "opensearch",
@@ -286,47 +291,27 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __postgres_schema() -> dict:
-        # Todo: Move to Postgres provider?
-        _valid_postgres_plans = Or(
-            "tiny",
-            "small",
-            "small-ha",
-            "small-high-io",
-            "medium",
-            "medium-ha",
-            "medium-high-io",
-            "large",
-            "large-ha",
-            "large-high-io",
-            "x-large",
-            "x-large-ha",
-            "x-large-high-io",
-            "2x-large",
-            "2x-large-ha",
-            "2x-large-high-io",
-            "4x-large",
-            "4x-large-ha",
-            "4x-large-high-io",
-        )
+        _valid_postgres_plans = Or(*plan_manager.get_plan_names("postgres"))
+        _valid_postgres_version = Or(int, float)
 
-        # Todo: Move to Postgres provider?
+        # TODO: DBTP-1943: Move to Postgres provider?
         _valid_postgres_storage_types = Or("gp2", "gp3", "io1", "io2")
 
         _valid_postgres_database_copy = {
             "from": PlatformConfigSchema.__valid_environment_name(),
             "to": PlatformConfigSchema.__valid_environment_name(),
-            Optional("from_account"): str,
-            Optional("to_account"): str,
             Optional("pipeline"): {Optional("schedule"): str},
         }
 
         return {
             "type": "postgres",
-            "version": (Or(int, float)),
+            Optional("version"): _valid_postgres_version,
             Optional("deletion_policy"): PlatformConfigSchema.__valid_postgres_deletion_policy(),
             Optional("environments"): {
                 PlatformConfigSchema.__valid_environment_name(): {
+                    Optional("apply_immediately"): bool,
                     Optional("plan"): _valid_postgres_plans,
+                    Optional("version"): (Or(int, float)),
                     Optional("volume_size"): PlatformConfigSchema.is_integer_between(20, 10000),
                     Optional("iops"): PlatformConfigSchema.is_integer_between(1000, 9950),
                     Optional("snapshot_id"): str,
@@ -336,9 +321,6 @@ class PlatformConfigSchema:
                     Optional("deletion_protection"): bool,
                     Optional("multi_az"): bool,
                     Optional("storage_type"): _valid_postgres_storage_types,
-                    Optional("backup_retention_days"): PlatformConfigSchema.is_integer_between(
-                        1, 35
-                    ),
                 }
             },
             Optional("database_copy"): [_valid_postgres_database_copy],
@@ -364,21 +346,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __redis_schema() -> dict:
-        # Todo move to Redis provider?
-        _valid_redis_plans = Or(
-            "micro",
-            "micro-ha",
-            "tiny",
-            "tiny-ha",
-            "small",
-            "small-ha",
-            "medium",
-            "medium-ha",
-            "large",
-            "large-ha",
-            "x-large",
-            "x-large-ha",
-        )
+        _valid_redis_plans = Or(*plan_manager.get_plan_names("redis"))
 
         return {
             "type": "redis",
@@ -398,7 +366,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def valid_s3_bucket_name(name: str):
-        # Todo: This is a public method becasue that's what the test expect. Perhaps it belongs in an S3 provider?
+        # TODO: DBTP-1943: This is a public method becasue that's what the test expect. Perhaps it belongs in an S3 provider?
         errors = []
         if not (2 < len(name) < 64):
             errors.append("Length must be between 3 and 63 characters inclusive.")
@@ -427,13 +395,36 @@ class PlatformConfigSchema:
                 errors.append(f"Names cannot be suffixed '{suffix}'.")
 
         if errors:
-            # Todo: Raise suitable PlatformException?
+            # TODO: DBTP-1943: Raise suitable PlatformException?
             raise SchemaError(
-                "Bucket name '{}' is invalid:\n{}".format(name, "\n".join(f"  {e}" for e in errors))
+                f"Bucket name '{name}' is invalid:\n" + "\n".join(f"  {e}" for e in errors)
             )
 
         return True
 
+    @staticmethod
+    def __datadog_schema() -> dict:
+        return {
+            "type": "datadog",
+            Optional("environments"): {
+                Optional(PlatformConfigSchema.__valid_environment_name()): {
+                    "team_name": str,
+                    Optional("contact_name"): str,
+                    Optional("contact_email"): str,
+                    Optional("contacts"): [
+                        {
+                            "name": str,
+                            "type": str,
+                            "contact": str,
+                        }
+                    ],
+                    Optional("documentation_url"): str,
+                    "services_to_monitor": dict,
+                    Optional("description"): str,
+                },
+            },
+        }
+
     @staticmethod
     def __s3_bucket_schema() -> dict:
         def _valid_s3_bucket_arn(key):
@@ -506,7 +497,9 @@ class PlatformConfigSchema:
                         },
                         Optional("cross_environment_service_access"): {
                             PlatformConfigSchema.__valid_schema_key(): {
-                                "application": str,
+                                # Deprecated: We didn't implement cross application access, no service teams are asking for it.
+                                # application should be removed once we can confirm that no-one is using it.
+                                Optional("application"): str,
                                 "environment": PlatformConfigSchema.__valid_environment_name(),
                                 "account": str,
                                 "service": str,
@@ -538,10 +531,10 @@ class PlatformConfigSchema:
 
     @staticmethod
     def string_matching_regex(regex_pattern: str) -> Callable:
-        # Todo public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
+        # TODO: DBTP-1943: public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
         def validate(string):
             if not re.match(regex_pattern, string):
-                # Todo: Raise suitable PlatformException?
+                # TODO: DBTP-1943: Raise suitable PlatformException?
                 raise SchemaError(
                     f"String '{string}' does not match the required pattern '{regex_pattern}'."
                 )
@@ -551,11 +544,11 @@ class PlatformConfigSchema:
 
     @staticmethod
     def is_integer_between(lower_limit, upper_limit) -> Callable:
-        # Todo public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
+        # TODO: DBTP-1943: public for the unit tests, not sure about testing what could be a private method. Perhaps it's covered by other tests anyway?
         def validate(value):
             if isinstance(value, int) and lower_limit <= value <= upper_limit:
                 return True
-            # Todo: Raise suitable PlatformException?
+            # TODO: DBTP-1943: Raise suitable PlatformException?
             raise SchemaError(f"should be an integer between {lower_limit} and {upper_limit}")
 
         return validate
@@ -569,7 +562,7 @@ class PlatformConfigSchema:
 
     @staticmethod
     def __valid_branch_name() -> Callable:
-        # Todo: Make this actually validate a git branch name properly; https://git-scm.com/docs/git-check-ref-format
+        # TODO: DBTP-1943: Make this actually validate a git branch name properly; https://git-scm.com/docs/git-check-ref-format
         return PlatformConfigSchema.string_matching_regex(r"^((?!\*).)*(\*)?$")
 
     @staticmethod
@@ -615,10 +608,10 @@ class PlatformConfigSchema:
 
 
 class ConditionalOpensSearchSchema(Schema):
-    # Todo: Move to OpenSearch provider?
+    # TODO: DBTP-1943: Move to OpenSearch provider?
     _valid_opensearch_min_volume_size: int = 10
 
-    # Todo: Move to OpenSearch provider?
+    # TODO: DBTP-1943: Move to OpenSearch provider?
     _valid_opensearch_max_volume_size: dict = {
         "tiny": 100,
         "small": 200,
@@ -652,11 +645,11 @@ class ConditionalOpensSearchSchema(Schema):
 
                 if volume_size:
                     if not plan:
-                        # Todo: Raise suitable PlatformException?
+                        # TODO: DBTP-1943: Raise suitable PlatformException?
                         raise SchemaError(f"Missing key: 'plan'")
 
                     if volume_size < self._valid_opensearch_min_volume_size:
-                        # Todo: Raise suitable PlatformException?
+                        # TODO: DBTP-1943: Raise suitable PlatformException?
                         raise SchemaError(
                             f"Key 'environments' error: Key '{env}' error: Key 'volume_size' error: should be an integer greater than {self._valid_opensearch_min_volume_size}"
                         )
@@ -666,7 +659,7 @@ class ConditionalOpensSearchSchema(Schema):
                             plan == key
                             and not volume_size <= self._valid_opensearch_max_volume_size[key]
                         ):
-                            # Todo: Raise suitable PlatformException?
+                            # TODO: DBTP-1943: Raise suitable PlatformException?
                             raise SchemaError(
                                 f"Key 'environments' error: Key '{env}' error: Key 'volume_size' error: should be an integer between {self._valid_opensearch_min_volume_size} and {self._valid_opensearch_max_volume_size[key]} for plan {plan}"
                             )

dbt_platform_helper/entities/semantic_version.py

@@ -0,0 +1,83 @@
+import re
+from typing import Union
+
+from dbt_platform_helper.providers.validation import ValidationException
+
+
+class IncompatibleMajorVersionException(ValidationException):
+    def __init__(self, app_version: str, check_version: str):
+        super().__init__()
+        self.app_version = app_version
+        self.check_version = check_version
+
+
+class IncompatibleMinorVersionException(ValidationException):
+    def __init__(self, app_version: str, check_version: str):
+        super().__init__()
+        self.app_version = app_version
+        self.check_version = check_version
+
+
+class SemanticVersion:
+    def __init__(self, major: int, minor: int, patch: int):
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+
+    def __str__(self) -> str:
+        if self.major is None:
+            return "unknown"
+        return ".".join([str(s) for s in [self.major, self.minor, self.patch]])
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __lt__(self, other) -> bool:
+        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
+
+    def __eq__(self, other) -> bool:
+        if other is None:
+            return False
+        return (self.major, self.minor, self.patch) == (other.major, other.minor, other.patch)
+
+    def validate_compatibility_with(self, other):
+        if other is None:
+            raise ValidationException("Cannot compare NoneType")
+        if (self.major == 0 and other.major == 0) and (
+            self.minor != other.minor or self.patch != other.patch
+        ):
+            raise IncompatibleMajorVersionException(str(self), str(other))
+
+        if self.major != other.major:
+            raise IncompatibleMajorVersionException(str(self), str(other))
+
+        if self.minor != other.minor:
+            raise IncompatibleMinorVersionException(str(self), str(other))
+
+    @staticmethod
+    def _cast_to_int_with_fallback(input, fallback=-1):
+        try:
+            return int(input)
+        except ValueError:
+            return fallback
+
+    @classmethod
+    def from_string(self, version_string: Union[str, None]):
+        if version_string is None:
+            return None
+
+        version_segments = re.split(r"[.\-]", version_string.replace("v", ""))
+
+        if len(version_segments) != 3:
+            return None
+
+        major, minor, patch = [self._cast_to_int_with_fallback(s) for s in version_segments]
+
+        return SemanticVersion(major, minor, patch)
+
+    @staticmethod
+    def is_semantic_version(version_string):
+        if not version_string:
+            return False
+        valid_semantic_string_regex = r"(?i)^v?[0-9]+[.-][0-9]+[.-][0-9]+$"
+        return re.match(valid_semantic_string_regex, version_string)