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

dbt_platform_helper/providers/config.py

@@ -1,28 +1,27 @@
 from copy import deepcopy
 from pathlib import Path
 
-import click
 from schema import SchemaError
 
 from dbt_platform_helper.constants import PLATFORM_CONFIG_FILE
 from dbt_platform_helper.domain.config_validator import ConfigValidator
+from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.platform_config_schema import PlatformConfigSchema
 from dbt_platform_helper.providers.yaml_file import FileNotFoundException
 from dbt_platform_helper.providers.yaml_file import FileProviderException
 from dbt_platform_helper.providers.yaml_file import YamlFileProvider
-from dbt_platform_helper.utils.messages import abort_with_error
 
 
 class ConfigProvider:
     def __init__(
         self,
-        config_validator: ConfigValidator,
+        config_validator: ConfigValidator = None,
         file_provider: YamlFileProvider = None,
-        echo=click.secho,
+        io: ClickIOProvider = None,
     ):
         self.config = {}
-        self.validator = config_validator
-        self.echo = echo
+        self.validator = config_validator or ConfigValidator()
+        self.io = io or ClickIOProvider()
         self.file_provider = file_provider or YamlFileProvider
 
     # TODO refactor so that apply_environment_defaults isn't set, discarded and set again
@@ -42,24 +41,23 @@ class ConfigProvider:
         try:
             self.config = self.file_provider.load(path)
         except FileNotFoundException as e:
-            abort_with_error(
+            self.io.abort_with_error(
                 f"{e} Please check it exists and you are in the root directory of your deployment project."
             )
         except FileProviderException as e:
-            abort_with_error(f"Error loading configuration from {path}: {e}")
+            self.io.abort_with_error(f"Error loading configuration from {path}: {e}")
 
         try:
             self.validate_platform_config()
         except SchemaError as e:
-            abort_with_error(f"Schema error in {path}. {e}")
+            self.io.abort_with_error(f"Schema error in {path}. {e}")
 
         return self.config
 
-    @staticmethod
     # TODO this general function should be moved out of ConfigProvider
-    def config_file_check(path=PLATFORM_CONFIG_FILE):
+    def config_file_check(self, path=PLATFORM_CONFIG_FILE):
         if not Path(path).exists():
-            abort_with_error(
+            self.io.abort_with_error(
                 f"`{path}` is missing. "
                 "Please check it exists and you are in the root directory of your deployment project."
             )

dbt_platform_helper/providers/io.py

@@ -0,0 +1,31 @@
+import click
+
+from dbt_platform_helper.platform_exception import PlatformException
+
+
+class ClickIOProvider:
+    def warn(self, message: str):
+        click.secho(message, fg="magenta")
+
+    def error(self, message: str):
+        click.secho(f"Error: {message}", fg="red")
+
+    def info(self, message: str):
+        click.secho(message)
+
+    def input(self, message: str) -> str:
+        return click.prompt(message)
+
+    def confirm(self, message: str) -> bool:
+        try:
+            return click.confirm(message)
+        except click.Abort:
+            raise ClickIOProviderException(message + " [y/N]: Error: invalid input")
+
+    def abort_with_error(self, message: str):
+        click.secho(f"Error: {message}", err=True, fg="red")
+        exit(1)
+
+
+class ClickIOProviderException(PlatformException):
+    pass

dbt_platform_helper/providers/load_balancers.py

@@ -2,8 +2,11 @@ import boto3
 
 from dbt_platform_helper.platform_exception import PlatformException
 
+# TODO - a good candidate for a dataclass when this is refactored into a class.
+# Below methods should also really be refactored to not be so tightly coupled with eachother.
 
-def find_load_balancer(session: boto3.Session, app: str, env: str) -> str:
+
+def get_load_balancer_for_application(session: boto3.Session, app: str, env: str) -> str:
     lb_client = session.client("elbv2")
 
     describe_response = lb_client.describe_load_balancers()
@@ -23,8 +26,8 @@ def find_load_balancer(session: boto3.Session, app: str, env: str) -> str:
     return load_balancer_arn
 
 
-def find_https_listener(session: boto3.Session, app: str, env: str) -> str:
-    load_balancer_arn = find_load_balancer(session, app, env)
+def get_https_listener_for_application(session: boto3.Session, app: str, env: str) -> str:
+    load_balancer_arn = get_load_balancer_for_application(session, app, env)
     lb_client = session.client("elbv2")
     listeners = lb_client.describe_listeners(LoadBalancerArn=load_balancer_arn)["Listeners"]
 
@@ -41,6 +44,22 @@ def find_https_listener(session: boto3.Session, app: str, env: str) -> str:
     return listener_arn
 
 
+def get_https_certificate_for_application(session: boto3.Session, app: str, env: str) -> str:
+
+    listener_arn = get_https_listener_for_application(session, app, env)
+    cert_client = session.client("elbv2")
+    certificates = cert_client.describe_listener_certificates(ListenerArn=listener_arn)[
+        "Certificates"
+    ]
+
+    try:
+        certificate_arn = next(c["CertificateArn"] for c in certificates if c["IsDefault"])
+    except StopIteration:
+        raise CertificateNotFoundException(env)
+
+    return certificate_arn
+
+
 class LoadBalancerException(PlatformException):
     pass
 
@@ -55,3 +74,10 @@ class ListenerNotFoundException(LoadBalancerException):
 
 class ListenerRuleNotFoundException(LoadBalancerException):
     pass
+
+
+class CertificateNotFoundException(PlatformException):
+    def __init__(self, environment_name: str):
+        super().__init__(
+            f"""No certificate found with domain name matching environment {environment_name}."."""
+        )

dbt_platform_helper/providers/platform_config_schema.py

@@ -443,14 +443,17 @@ class PlatformConfigSchema:
                 error=f"{key} must contain a valid ARN for an S3 bucket",
             )
 
+        _single_import_config = {
+            Optional("source_kms_key_arn"): PlatformConfigSchema.__valid_kms_key_arn(
+                "source_kms_key_arn"
+            ),
+            "source_bucket_arn": _valid_s3_bucket_arn("source_bucket_arn"),
+            "worker_role_arn": PlatformConfigSchema.__valid_iam_role_arn("worker_role_arn"),
+        }
+
         _valid_s3_data_migration = {
-            "import": {
-                Optional("source_kms_key_arn"): PlatformConfigSchema.__valid_kms_key_arn(
-                    "source_kms_key_arn"
-                ),
-                "source_bucket_arn": _valid_s3_bucket_arn("source_bucket_arn"),
-                "worker_role_arn": PlatformConfigSchema.__valid_iam_role_arn("worker_role_arn"),
-            },
+            Optional("import"): _single_import_config,
+            Optional("import_sources"): [_single_import_config],
         }
 
         _valid_s3_bucket_retention_policy = Or(

dbt_platform_helper/providers/vpc.py

@@ -1,57 +1,106 @@
 from dataclasses import dataclass
 
-from dbt_platform_helper.providers.aws import AWSException
+from dbt_platform_helper.platform_exception import PlatformException
+
+
+class VpcProviderException(PlatformException):
+    pass
+
+
+class SubnetsNotFoundException(VpcProviderException):
+    pass
+
+
+class PrivateSubnetsNotFoundException(VpcProviderException):
+    pass
+
+
+class PublicSubnetsNotFoundException(VpcProviderException):
+    pass
+
+
+class SecurityGroupNotFoundException(VpcProviderException):
+    pass
+
+
+class VpcNotFoundForNameException(VpcProviderException):
+    pass
+
+
+class VpcIdMissingException(VpcProviderException):
+    pass
 
 
 @dataclass
 class Vpc:
-    subnets: list[str]
+    id: str
+    public_subnets: list[str]
+    private_subnets: list[str]
     security_groups: list[str]
 
 
 class VpcProvider:
     def __init__(self, session):
         self.ec2_client = session.client("ec2")
-        self.ec2_resource = session.resource("ec2")
 
-    def get_vpc_info_by_name(self, app: str, env: str, vpc_name: str) -> Vpc:
-        vpc_response = self.ec2_client.describe_vpcs(
-            Filters=[{"Name": "tag:Name", "Values": [vpc_name]}]
-        )
+    def _get_subnet_ids(self, vpc_id):
+        subnets = self.ec2_client.describe_subnets(
+            Filters=[{"Name": "vpc-id", "Values": [vpc_id]}]
+        ).get("Subnets")
+
+        if not subnets:
+            raise SubnetsNotFoundException(f"No subnets found for VPC with id: {vpc_id}.")
+
+        public_tag = {"Key": "subnet_type", "Value": "public"}
+        public_subnets = [subnet["SubnetId"] for subnet in subnets if public_tag in subnet["Tags"]]
 
-        matching_vpcs = vpc_response.get("Vpcs", [])
+        private_tag = {"Key": "subnet_type", "Value": "private"}
+        private_subnets = [
+            subnet["SubnetId"] for subnet in subnets if private_tag in subnet["Tags"]
+        ]
 
-        if not matching_vpcs:
-            raise AWSException(f"VPC not found for name '{vpc_name}'")
+        return public_subnets, private_subnets
 
-        vpc_id = vpc_response["Vpcs"][0].get("VpcId")
+    def _get_vpc_id_by_name(self, vpc_name: str) -> str:
+        vpcs = self.ec2_client.describe_vpcs(
+            Filters=[{"Name": "tag:Name", "Values": [vpc_name]}]
+        ).get("Vpcs", [])
+
+        if not vpcs:
+            raise VpcNotFoundForNameException(f"VPC not found for name '{vpc_name}'")
+
+        vpc_id = vpcs[0].get("VpcId")
 
         if not vpc_id:
-            raise AWSException(f"VPC id not present in vpc '{vpc_name}'")
+            raise VpcIdMissingException(f"VPC id not present in vpc '{vpc_name}'")
 
-        vpc = self.ec2_resource.Vpc(vpc_id)
+        return vpc_id
 
-        route_tables = self.ec2_client.describe_route_tables(
-            Filters=[{"Name": "vpc-id", "Values": [vpc_id]}]
-        )["RouteTables"]
-
-        subnets = []
-        for route_table in route_tables:
-            private_routes = [route for route in route_table["Routes"] if "NatGatewayId" in route]
-            if not private_routes:
-                continue
-            for association in route_table["Associations"]:
-                if "SubnetId" in association:
-                    subnet_id = association["SubnetId"]
-                    subnets.append(subnet_id)
+    def _get_security_groups(self, app: str, env: str, vpc_id: str) -> list:
 
-        if not subnets:
-            raise AWSException(f"No private subnets found in vpc '{vpc_name}'")
+        vpc_filter = {"Name": "vpc-id", "Values": [vpc_id]}
+        tag_filter = {"Name": f"tag:Name", "Values": [f"copilot-{app}-{env}-env"]}
+        response = self.ec2_client.describe_security_groups(Filters=[vpc_filter, tag_filter])
+
+        return [sg.get("GroupId") for sg in response.get("SecurityGroups")]
+
+    def get_vpc(self, app: str, env: str, vpc_name: str) -> Vpc:
+
+        vpc_id = self._get_vpc_id_by_name(vpc_name)
+
+        public_subnets, private_subnets = self._get_subnet_ids(vpc_id)
+
+        if not private_subnets:
+            raise PrivateSubnetsNotFoundException(f"No private subnets found in vpc '{vpc_name}'")
+
+        if not public_subnets:
+            raise PublicSubnetsNotFoundException(f"No public subnets found in vpc '{vpc_name}'")
 
-        tag_value = {"Key": "Name", "Value": f"copilot-{app}-{env}-env"}
-        sec_groups = [sg.id for sg in vpc.security_groups.all() if sg.tags and tag_value in sg.tags]
+        sec_groups = self._get_security_groups(app, env, vpc_id)
 
         if not sec_groups:
-            raise AWSException(f"No matching security groups found in vpc '{vpc_name}'")
+            raise SecurityGroupNotFoundException(
+                f"No matching security groups found in vpc '{vpc_name}'"
+            )
 
-        return Vpc(subnets, sec_groups)
+        return Vpc(vpc_id, public_subnets, private_subnets, sec_groups)

dbt_platform_helper/templates/COMMANDS.md.jinja

@@ -1,8 +1,10 @@
 # Commands Reference
 
-{% for command in toc -%}
-- [{{ command }}](#{{ command.lower() | replace(" ", "-") }})
-{% endfor %}
+{% for meta in metadata -%}
+{% if meta.name -%}
+{{ meta.indent }}- [{{ meta.name }}](#{{ meta.name.lower() | replace(" ", "-") }})
+{% endif -%}
+{% endfor -%}
 
 {%- for meta in metadata +%}
 {% if meta.name -%}