dbt-platform-helper 15.10.0__py3-none-any.whl → 15.11.0__py3-none-any.whl

dbt_platform_helper/domain/update_alb_rules.py

@@ -0,0 +1,346 @@
+import copy
+from dataclasses import dataclass
+from dataclasses import field
+from enum import Enum
+from typing import List
+
+from dbt_platform_helper.constants import COPILOT_RULE_PRIORITY
+from dbt_platform_helper.constants import DUMMY_RULE_REASON
+from dbt_platform_helper.constants import MAINTENANCE_PAGE_REASON
+from dbt_platform_helper.constants import MANAGED_BY_PLATFORM
+from dbt_platform_helper.constants import MANAGED_BY_SERVICE_TERRAFORM
+from dbt_platform_helper.constants import PLATFORM_RULE_STARTING_PRIORITY
+from dbt_platform_helper.constants import RULE_PRIORITY_INCREMENT
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.config import ConfigProvider
+from dbt_platform_helper.providers.config_validator import ConfigValidator
+from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.load_balancers import LoadBalancerProvider
+from dbt_platform_helper.utils.application import load_application
+
+
+class RollbackException(PlatformException):
+    pass
+
+
+class RuleType(Enum):
+    PLATFORM = "platform"
+    MAINTENANCE = "maintenance"
+    DEFAULT = "default"
+    COPILOT = "copilot"
+    MANUAL = "manual"
+    DUMMY = "dummy"
+
+
+class Deployment(Enum):
+    PLATFORM = "platform"
+    COPILOT = "copilot"
+    DUAL_DEPLOY_PLATFORM = "dual-deploy-platform-traffic"
+    DUAL_DEPLOY_COPILOT = "dual-deploy-copilot-traffic"
+
+
+@dataclass
+class OperationState:
+    created_rules: List[str] = field(default_factory=list)
+    deleted_rules: List[object] = field(default_factory=list)
+    listener_arn: str = ""
+
+
+class UpdateALBRules:
+
+    def __init__(
+        self,
+        session,
+        config_provider: ConfigProvider = ConfigProvider(ConfigValidator()),
+        io: ClickIOProvider = ClickIOProvider(),
+        load_application=load_application,
+        load_balancer_p: LoadBalancerProvider = LoadBalancerProvider,
+    ):
+        self.config_provider = config_provider
+        self.io = io
+        self.load_application = load_application
+        self.load_balancer: LoadBalancerProvider = load_balancer_p(session, io=self.io)
+
+    def update_alb_rules(
+        self,
+        environment: str,
+    ):
+        """
+        Change ALB rules for a given environment.
+
+        Attempt to rollback the rules created/deleted if a failure occurs.
+        """
+
+        operation_state = OperationState()
+
+        try:
+            self._execute_rule_updates(environment, operation_state)
+            if operation_state.created_rules:
+                self.io.info(f"Created rules: {operation_state.created_rules}")
+            if operation_state.deleted_rules:
+                deleted_arns = [rule["RuleArn"] for rule in operation_state.deleted_rules]
+                self.io.info(f"Deleted rules: {deleted_arns}")
+        except Exception as e:
+            if operation_state.created_rules or operation_state.deleted_rules:
+                self.io.error(f"Error during rule update: {str(e)}")
+                self.io.warn("Rolling back")
+                self.io.info("Attempting to rollback changes ...")
+                try:
+                    self._rollback_changes(operation_state)
+                except RollbackException as rollback_error:
+                    raise PlatformException(f"Rollback failed: \n{str(rollback_error)}")
+            else:
+                raise
+
+    def _execute_rule_updates(self, environment: str, operation_state: OperationState):
+        platform_config = self.config_provider.get_enriched_config()
+
+        application_name = platform_config.get("application", "")
+        application = self.load_application(app=application_name)
+
+        service_deployment_mode = (
+            platform_config.get("environments")
+            .get(environment, {})
+            .get("service-deployment-mode", Deployment.COPILOT.value)
+        )
+
+        self.io.info(f"Deployment Mode: {service_deployment_mode}")
+
+        listener_arn = self.load_balancer.get_https_listener_for_application(
+            application.name, environment
+        )
+
+        operation_state.listener_arn = listener_arn
+
+        self.io.debug(f"Listener ARN: {listener_arn}")
+
+        rules = self.load_balancer.get_rules_with_tags_by_listener_arn(listener_arn)
+
+        mapped_rules = {
+            rule_type: [rule for rule in rules if self._filter_rule_type(rule) == rule_type]
+            for rule_type in set(self._filter_rule_type(rule) for rule in rules)
+        }
+
+        if mapped_rules.get(RuleType.MANUAL.value, []):
+            rule_arns = [rule["RuleArn"] for rule in mapped_rules[RuleType.MANUAL.value]]
+            message = f"""The following rules have been created manually please review and if required set 
+            the rules priority to the copilot range after priority: {COPILOT_RULE_PRIORITY}.\n
+            Rules: {rule_arns}"""
+            raise PlatformException(message)
+
+        if (
+            service_deployment_mode == Deployment.PLATFORM.value
+            or service_deployment_mode == Deployment.DUAL_DEPLOY_PLATFORM.value
+        ):
+
+            if len(mapped_rules.get(RuleType.PLATFORM.value, [])) > 0 and len(
+                mapped_rules.get(RuleType.PLATFORM.value, [])
+            ) != len(mapped_rules.get(RuleType.COPILOT.value, [])):
+                raise PlatformException("Platform rules are partially created, please review.")
+
+            if len(mapped_rules.get(RuleType.PLATFORM.value, [])) == len(
+                mapped_rules.get(RuleType.COPILOT.value, [])
+            ):
+                self.io.info("Platform rules already exist, skipping creation")
+                return  # early exit
+
+            grouped = dict()
+
+            service_mapped_tgs = self._get_tg_arns_for_platform_services(
+                application_name, environment
+            )
+            for copilot_rule in mapped_rules.get(RuleType.COPILOT.value, []):
+                rule_arn = copilot_rule["RuleArn"]
+                self.io.debug(f"Building platform rule for corresponding copilot rule: {rule_arn}")
+                sorted_hosts = sorted(copilot_rule["Conditions"].get("host-header", []))
+                # Depth represents the specificity of the path condition, allowing us to sort in decreasing complexity.
+                path_depth = max(
+                    [
+                        len([sub_path for sub_path in path.split("/") if sub_path])
+                        for path in copilot_rule["Conditions"].get("path-pattern", [])
+                    ]
+                )
+                list_conditions = [
+                    {"Field": key, "Values": value}
+                    for key, value in copilot_rule["Conditions"].items()
+                ]
+
+                service_name = self._get_service_from_tg(copilot_rule)
+
+                tg_arn = service_mapped_tgs[service_name]
+
+                actions = self._create_new_actions(copilot_rule["Actions"], tg_arn)
+                self.io.debug(f"Updated forward action for service {service_name} to use: {tg_arn}")
+                if grouped.get(",".join(sorted_hosts)):
+                    grouped[",".join(sorted_hosts)].append(
+                        {
+                            "copilot_rule": rule_arn,
+                            "actions": actions,
+                            "conditions": list_conditions,
+                            "path_depth": path_depth,
+                            "service_name": service_name,
+                        }
+                    )
+                else:
+                    grouped[",".join(sorted_hosts)] = [
+                        {
+                            "copilot_rule": rule_arn,
+                            "actions": actions,
+                            "conditions": list_conditions,
+                            "path_depth": path_depth,
+                            "service_name": service_name,
+                        }
+                    ]
+
+            rule_priority = PLATFORM_RULE_STARTING_PRIORITY
+            for hosts, rules in grouped.items():
+                rules.sort(key=lambda x: x["path_depth"], reverse=True)
+
+                for rule in rules:
+                    # Create rule with priority
+                    copilot_rule = rule.get("copilot_rule", "")
+                    self.io.debug(
+                        f"Creating platform rule for corresponding copilot rule: {copilot_rule}"
+                    )
+                    rule_arn = self.load_balancer.create_rule(
+                        listener_arn,
+                        rule["actions"],
+                        rule["conditions"],
+                        rule_priority,
+                        tags=[
+                            {"Key": "application", "Value": application_name},
+                            {"Key": "environment", "Value": environment},
+                            {"Key": "service", "Value": rule["service_name"]},
+                            {"Key": "reason", "Value": "service"},
+                            {"Key": "managed-by", "Value": MANAGED_BY_PLATFORM},
+                        ],
+                    )["Rules"][0]["RuleArn"]
+                    operation_state.created_rules.append(rule_arn)
+                    rule_priority += RULE_PRIORITY_INCREMENT
+
+                next_thousandth = lambda x: ((x // 1000) + 1) * 1000
+                rule_priority = next_thousandth(rule_priority)
+
+        if (
+            service_deployment_mode == Deployment.COPILOT.value
+            or service_deployment_mode == Deployment.DUAL_DEPLOY_COPILOT.value
+        ):
+            self._delete_rules(mapped_rules.get(RuleType.PLATFORM.value, []), operation_state)
+
+    def _delete_rules(self, rules: List[dict], operation_state: OperationState):
+        for rule in rules:
+            rule_arn = rule["RuleArn"]
+            try:
+                self.load_balancer.delete_listener_rule_by_resource_arn(rule_arn)
+                operation_state.deleted_rules.append(rule)
+                self.io.debug(f"Deleted existing rule: {rule_arn}")
+            except Exception as e:
+                self.io.error(f"Failed to delete existing rule {rule_arn}: {str(e)}")
+                raise
+
+    def _filter_rule_type(self, rule: dict) -> str:
+        if rule["Tags"]:
+            if rule["Tags"].get("managed-by", "") == MANAGED_BY_PLATFORM:
+                return RuleType.PLATFORM.value
+            if rule["Tags"].get("reason", None) == MAINTENANCE_PAGE_REASON:
+                return RuleType.MAINTENANCE.value
+            if rule["Tags"].get("reason", None) == DUMMY_RULE_REASON:
+                return RuleType.DUMMY.value
+
+        if rule["Priority"] == "default":
+            return RuleType.DEFAULT.value
+        if int(rule["Priority"]) >= COPILOT_RULE_PRIORITY:
+            return RuleType.COPILOT.value
+
+        return RuleType.MANUAL.value
+
+    def _get_service_from_tg(self, rule: dict) -> str:
+        target_group_arn = None
+
+        for action in rule["Actions"]:
+            if action["Type"] == "forward":
+                target_group_arn = action["TargetGroupArn"]
+
+        if target_group_arn:
+            try:
+                tgs = self.load_balancer.get_target_groups_with_tags([target_group_arn])
+                return tgs[0]["Tags"].get("copilot-service", None)
+            except IndexError:
+                raise PlatformException(f"No target group found for arn: {target_group_arn}")
+        else:
+            rule_arn = rule["RuleArn"]
+            raise PlatformException(f"No target group arn found in rule: {rule_arn}")
+
+    def _get_tg_arns_for_platform_services(
+        self, application: str, environment: str, managed_by: str = MANAGED_BY_SERVICE_TERRAFORM
+    ) -> dict:
+        tgs = self.load_balancer.get_target_groups_with_tags([])
+        service_mapped_tgs = {}
+        for tg in tgs:
+            if (
+                tg["Tags"].get("application", "") == application
+                and tg["Tags"].get("environment", "") == environment
+                and tg["Tags"].get("managed-by", "") == managed_by
+            ):
+                if tg["Tags"].get("service", ""):
+                    service_mapped_tgs[tg["Tags"].get("service")] = tg["TargetGroupArn"]
+                else:
+                    tg_name = tg["TargetGroupName"]
+                    self.io.warn(f"Target group {tg_name} has no 'service' tag")
+        return service_mapped_tgs
+
+    def _create_new_actions(self, actions: dict, tg_arn: str) -> dict:
+
+        updated_actions = copy.deepcopy(actions)
+        for action in updated_actions:
+            if action.get("Type") == "forward" and "TargetGroupArn" in action:
+                action["TargetGroupArn"] = tg_arn
+                for tg in action["ForwardConfig"]["TargetGroups"]:
+                    tg["TargetGroupArn"] = tg_arn
+        return updated_actions
+
+    def _rollback_changes(self, operation_state: OperationState) -> bool:
+        rollback_errors = []
+        delete_rollbacks = []
+        create_rollbacks = []
+        for rule_arn in operation_state.created_rules:
+            try:
+                self.io.debug(f"Rolling back: Deleting created rule {rule_arn}")
+                self.load_balancer.delete_listener_rule_by_resource_arn(rule_arn)
+                delete_rollbacks.append(rule_arn)
+            except Exception as e:
+                error_msg = f"Failed to delete rule {rule_arn} during rollback: {str(e)}"
+                rollback_errors.append(error_msg)
+
+        for rule_snapshot in operation_state.deleted_rules:
+            rule_arn = rule_snapshot["RuleArn"]
+            try:
+                self.io.debug(f"Rolling back: Recreating deleted rule {rule_arn}")
+                create_rollbacks.append(
+                    self.load_balancer.create_rule(
+                        operation_state.listener_arn,
+                        actions=rule_snapshot["Actions"],
+                        conditions=[
+                            {"Field": key, "Values": value}
+                            for key, value in rule_snapshot["Conditions"].items()
+                        ],
+                        priority=int(rule_snapshot["Priority"]),
+                        tags=[
+                            {"Key": key, "Value": value}
+                            for key, value in rule_snapshot["Tags"].items()
+                        ],
+                    )["Rules"][0]["RuleArn"]
+                )
+            except Exception as e:
+                error_msg = f"Failed to recreate rule {rule_arn} during rollback: {str(e)}"
+                rollback_errors.append(error_msg)
+
+        if rollback_errors:
+            self.io.warn("Some rollback operations failed. Manual intervention may be required.")
+            errors = "\n".join(rollback_errors)
+            raise RollbackException(f"Rollback partially failed: {errors}")
+        else:
+            self.io.info("Rollback completed successfully")
+            self.io.info(
+                f"Rolledback rules by creating: {create_rollbacks} \n and deleting {delete_rollbacks}"
+            )

dbt_platform_helper/entities/platform_config_schema.py

@@ -321,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],

dbt_platform_helper/entities/service.py

@@ -1,3 +1,4 @@
+import re
 from typing import ClassVar
 from typing import Dict
 from typing import Optional
@@ -5,6 +6,10 @@ from typing import Union
 
 from pydantic import BaseModel
 from pydantic import Field
+from pydantic import field_validator
+from pydantic import model_validator
+
+from dbt_platform_helper.platform_exception import PlatformException
 
 
 class HealthCheck(BaseModel):
@@ -21,14 +26,22 @@ class HealthCheck(BaseModel):
     timeout: Optional[str] = Field(
         description="""The timeout for a healthcheck call""", default=None
     )
-    grace_period: Optional[str] = Field(description="""The time""", default=None)
+    grace_period: Optional[str] = Field(
+        description="""The time the service ignores unhealthy ALB and container health checks""",
+        default=None,
+    )
 
 
 class Http(BaseModel):
+    path: str = Field(description="""Requests to this path will be forwarded to your service.""")
+    target_container: str = Field(description="""Target container for the requests""")
+    healthcheck: Optional[HealthCheck] = Field(default=None)
+
+
+class HttpOverride(BaseModel):
     path: Optional[str] = Field(
         description="""Requests to this path will be forwarded to your service.""", default=None
     )
-    alb: Optional[str] = Field(default=None)
     target_container: Optional[str] = Field(
         description="""Target container for the requests""", default=None
     )
@@ -52,35 +65,135 @@ class SidecarOverride(BaseModel):
 
 
 class Image(BaseModel):
-    build: Optional[str] = Field(default=None)
-    location: Optional[str] = Field(default=None)
+    location: str = Field()
     port: Optional[int] = Field(default=None)
+    depends_on: Optional[dict[str, str]] = Field(default=None)
 
 
 class VPC(BaseModel):
-    placement: str = Field()
+    placement: Optional[str] = Field(default=None)
 
 
 class Network(BaseModel):
-    connect: bool = Field(
-        description="Enable Service Connect for intra-environment traffic between services."
+    connect: Optional[bool] = Field(
+        description="Enable Service Connect for intra-environment traffic between services.",
+        default=None,
     )
     vpc: Optional[VPC] = Field(default=None)
 
 
 class Storage(BaseModel):
-    readonly_fs: bool
+    readonly_fs: Optional[bool] = Field(default=None)
+    writable_directories: Optional[list[str]] = Field(default=None)
+
+    @field_validator("writable_directories", mode="after")
+    @classmethod
+    def has_leading_forward_slash(cls, value: Union[list, None]) -> Union[list, None]:
+        if value is not None:
+            for path in value:
+                if not path.startswith("/"):
+                    raise PlatformException(
+                        "All writable directory paths must be absolute (starts with a /)"
+                    )
+        return value
+
+
+class Cooldown(BaseModel):
+    in_: int = Field(
+        alias="in",
+        description="Number of seconds to wait before scaling in (down) after a drop in load.",
+    )  # Can't use 'in' because it's a reserved keyword
+    out: int = Field(
+        description="Number of seconds to wait before scaling out (up) after a spike in load."
+    )
+
+    @field_validator("in_", "out", mode="before")
+    @classmethod
+    def parse_seconds(cls, value):
+        if isinstance(value, str) and value.endswith("s"):
+            value = value.removesuffix("s")  # remove the trailing 's'
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            raise PlatformException("Cooldown values must be integers or strings like '30s'")
+
+
+class CpuPercentage(BaseModel):
+    value: int = Field(description="Target CPU utilisation percentage that triggers autoscaling.")
+    cooldown: Optional[Cooldown] = Field(
+        default=None, description="Optional CPU cooldown that overrides the global cooldown policy."
+    )
+
+
+class MemoryPercentage(BaseModel):
+    value: int = Field(description="Target CPU utilisation percentage that triggers autoscaling.")
+    cooldown: Optional[Cooldown] = Field(
+        default=None,
+        description="Optional memory cooldown that overrides the global cooldown policy.",
+    )
+
+
+class RequestsPerMinute(BaseModel):
+    value: int = Field(
+        description="Number of incoming requests per minute that triggers autoscaling."
+    )
+    cooldown: Optional[Cooldown] = Field(
+        default=None,
+        description="Optional requests cooldown that overrides the global cooldown policy.",
+    )
+
+
+class Count(BaseModel):
+    range: str = Field(
+        description="Minimum and maximum number of ECS tasks to maintain e.g. '1-2'."
+    )
+    cooldown: Optional[Cooldown] = Field(
+        default=None,
+        description="Global cooldown applied to all autoscaling metrics unless overridden per metric.",
+    )
+    cpu_percentage: Optional[Union[int, CpuPercentage]] = Field(
+        default=None,
+        description="CPU utilisation threshold (0–100). Either a plain integer or a map with 'value' and 'cooldown'.",
+    )
+    memory_percentage: Optional[Union[int, MemoryPercentage]] = Field(
+        default=None,
+        description="Memory utilisation threshold (0–100). Either a plain integer or a map with 'value' and 'cooldown'.",
+    )
+    requests_per_minute: Optional[Union[int, RequestsPerMinute]] = Field(
+        default=None,
+        description="Request-rate threshold. Either a plain integer or a map with 'value' and 'cooldown'.",
+    )
+
+    @model_validator(mode="after")
+    def at_least_one_autoscaling_metric(self):
+
+        if not any([self.cpu_percentage, self.memory_percentage, self.requests_per_minute]):
+            raise PlatformException(
+                "If autoscaling is enabled, you must define at least one metric: "
+                "cpu_percentage, memory_percentage, or requests_per_minute"
+            )
+
+        if not re.match(r"^(\d+)-(\d+)$", self.range):
+            raise PlatformException("Range must be in the format 'int-int' e.g. '1-2'")
+
+        range_split = self.range.split("-")
+        if range_split[0] >= range_split[1]:
+            raise PlatformException("Range minimum value must be less than the maximum value.")
+
+        return self
 
 
 class ServiceConfigEnvironmentOverride(BaseModel):
-    http: Optional[Http] = Field(default=None)
+    http: Optional[HttpOverride] = Field(default=None)
     sidecars: Optional[Dict[str, SidecarOverride]] = Field(default=None)
     image: Optional[Image] = Field(default=None)
 
     cpu: Optional[int] = Field(default=None)
     memory: Optional[int] = Field(default=None)
-    count: Optional[int] = Field(default=None)
+    count: Optional[Union[int, Count]] = Field(default=None)
     exec: Optional[bool] = Field(default=None)
+    entrypoint: Optional[list[str]] = Field(default=None)
+    essential: Optional[bool] = Field(default=None)
     network: Optional[Network] = Field(default=None)
 
     storage: Optional[Storage] = Field(default=None)
@@ -93,14 +206,27 @@ class ServiceConfig(BaseModel):
     name: str = Field(description="""Name of the Service.""")
     type: str = Field(description="""The type of service""")
 
-    http: Optional[Http] = Field(default=None)  # TODO http required if service type load balancer
+    http: Optional[Http] = Field(default=None)
+
+    @model_validator(mode="after")
+    def check_http_for_web_service(self):
+        if self.type == "Load Balanced Web Service" and self.http is None:
+            raise PlatformException(
+                "A 'http' block must be provided when service type == 'Load Balanced Web Service'"
+            )
+        return self
+
     sidecars: Optional[Dict[str, Sidecar]] = Field(default=None)
     image: Image = Field()
 
     cpu: int = Field()
     memory: int = Field()
-    count: int = Field()
+    count: Union[int, Count] = Field(
+        description="Desired task count — either a fixed integer or an autoscaling policy map with 'range', 'cooldown', and at least one of 'cpu_percentage', 'memory_percentage', or 'requests_per_minute' metrics."
+    )
     exec: Optional[bool] = Field(default=None)
+    entrypoint: Optional[list[str]] = Field(default=None)
+    essential: Optional[bool] = Field(default=None)
     network: Optional[Network] = Field(default=None)
 
     storage: Optional[Storage] = Field(default=None)
@@ -110,5 +236,5 @@ class ServiceConfig(BaseModel):
     # Environment overrides can override almost the full config
     environments: Optional[Dict[str, ServiceConfigEnvironmentOverride]] = Field(default=None)
 
-    # Class based variable used when handling the obejct
+    # Class based variable used when handling the object
     local_terraform_source: ClassVar[str] = "../../../../../platform-tools/terraform/ecs-service"

dbt_platform_helper/providers/aws/exceptions.py

@@ -63,3 +63,8 @@ class CreateAccessTokenException(AWSException):
 class UnableToRetrieveSSOAccountList(AWSException):
     def __init__(self):
         super().__init__("Unable to retrieve AWS SSO account list")
+
+
+class UnableToRetrieveSSOAccountRolesList(AWSException):
+    def __init__(self, account_id: str):
+        super().__init__(f"Unable to retrieve AWS SSO roles list for AWS account {account_id}")

dbt_platform_helper/providers/aws/sso_auth.py

@@ -3,6 +3,9 @@ from boto3 import Session
 
 from dbt_platform_helper.providers.aws.exceptions import CreateAccessTokenException
 from dbt_platform_helper.providers.aws.exceptions import UnableToRetrieveSSOAccountList
+from dbt_platform_helper.providers.aws.exceptions import (
+    UnableToRetrieveSSOAccountRolesList,
+)
 from dbt_platform_helper.utils.aws import get_aws_session_or_abort
 
 
@@ -55,6 +58,17 @@ class SSOAuthProvider:
             raise UnableToRetrieveSSOAccountList()
         return aws_accounts_response.get("accountList")
 
+    def list_account_roles(self, access_token, account_id, max_results=100):
+        aws_account_roles_response = self.sso.list_account_roles(
+            accessToken=access_token,
+            accountId=account_id,
+            maxResults=max_results,
+        )
+
+        if len(aws_account_roles_response.get("roleList", [])) == 0:
+            raise UnableToRetrieveSSOAccountRolesList(account_id=account_id)
+        return aws_account_roles_response.get("roleList")
+
     def _get_client(self, client: str):
         if not self.session:
             self.session = get_aws_session_or_abort()

dbt_platform_helper/providers/config.py

@@ -30,17 +30,6 @@ class ConfigLoader:
         self.io = io
         self.file_provider = file_provider
 
-    def load_into_model(self, path, model):
-        try:
-            file_content = self.file_provider.load(path)
-            return model(**file_content)
-        except FileNotFoundException as e:
-            self.io.abort_with_error(
-                f"{e} Please check it exists and you are in the root directory of your -deploy repository."
-            )
-        except FileProviderException as e:
-            self.io.abort_with_error(f"Error loading configuration from {path}: {e}")
-
     def load(self, path):
         try:
             file_content = self.file_provider.load(path)