dbt-platform-helper 13.2.0__py3-none-any.whl → 13.3.0__py3-none-any.whl

dbt_platform_helper/commands/codebase.py

@@ -4,6 +4,8 @@ from dbt_platform_helper.domain.codebase import Codebase
 from dbt_platform_helper.domain.versioning import PlatformHelperVersioning
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.parameter_store import ParameterStore
+from dbt_platform_helper.utils.aws import get_aws_session_or_abort
 from dbt_platform_helper.utils.click import ClickDocOptGroup
 
 
@@ -17,7 +19,7 @@ def codebase():
 def prepare():
     """Sets up an application codebase for use within a DBT platform project."""
     try:
-        Codebase().prepare()
+        Codebase(ParameterStore(get_aws_session_or_abort().client("ssm"))).prepare()
     except PlatformException as err:
         ClickIOProvider().abort_with_error(str(err))
 
@@ -33,7 +35,7 @@ def prepare():
 def list(app, with_images):
     """List available codebases for the application."""
     try:
-        Codebase().list(app, with_images)
+        Codebase(ParameterStore(get_aws_session_or_abort().client("ssm"))).list(app, with_images)
     except PlatformException as err:
         ClickIOProvider().abort_with_error(str(err))
 
@@ -49,7 +51,9 @@ def list(app, with_images):
 def build(app, codebase, commit):
     """Trigger a CodePipeline pipeline based build."""
     try:
-        Codebase().build(app, codebase, commit)
+        Codebase(ParameterStore(get_aws_session_or_abort().client("ssm"))).build(
+            app, codebase, commit
+        )
     except PlatformException as err:
         ClickIOProvider().abort_with_error(str(err))
 
@@ -65,6 +69,8 @@ def build(app, codebase, commit):
 @click.option("--commit", help="GitHub commit hash", required=True)
 def deploy(app, env, codebase, commit):
     try:
-        Codebase().deploy(app, env, codebase, commit)
+        Codebase(ParameterStore(get_aws_session_or_abort().client("ssm"))).deploy(
+            app, env, codebase, commit
+        )
     except PlatformException as err:
         ClickIOProvider().abort_with_error(str(err))

dbt_platform_helper/commands/config.py

@@ -1,56 +1,11 @@
-import os
-import webbrowser
-from pathlib import Path
-from typing import Dict
-
-import boto3
-import botocore
 import click
-from prettytable import PrettyTable
 
-from dbt_platform_helper.providers.config import ConfigProvider
+from dbt_platform_helper.domain.config import Config
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.aws.sso_auth import SSOAuthProvider
 from dbt_platform_helper.providers.io import ClickIOProvider
-from dbt_platform_helper.providers.semantic_version import (
-    IncompatibleMajorVersionException,
-)
-from dbt_platform_helper.providers.validation import ValidationException
-from dbt_platform_helper.utils import tool_versioning
+from dbt_platform_helper.utils.aws import get_aws_session_or_abort
 from dbt_platform_helper.utils.click import ClickDocOptGroup
-from dbt_platform_helper.utils.tool_versioning import get_platform_helper_version_status
-
-yes = "\033[92m✔\033[0m"
-no = "\033[91m✖\033[0m"
-maybe = "\033[93m?\033[0m"
-
-RECOMMENDATIONS = {
-    "dbt-platform-helper-upgrade": (
-        "Upgrade dbt-platform-helper to version {version} `pip install "
-        "--upgrade dbt-platform-helper=={version}`."
-    ),
-    "dbt-platform-helper-upgrade-note": (
-        "Post upgrade, run `platform-helper copilot make-addons` to " "update your addon templates."
-    ),
-    "generic-tool-upgrade": "Upgrade {tool} to version {version}.",
-}
-
-SSO_START_URL = "https://uktrade.awsapps.com/start"
-
-AWS_CONFIG = """
-#
-# uktrade
-#
-
-[sso-session uktrade]
-sso_start_url = https://uktrade.awsapps.com/start#/
-sso_region = eu-west-2
-sso_registration_scopes = sso:account:access
-
-[default]
-sso_session = uktrade
-region = eu-west-2
-output = json
-
-"""
 
 
 @click.group(cls=ClickDocOptGroup)
@@ -61,190 +16,10 @@ def config():
 @config.command()
 def validate():
     """Validate deployment or application configuration."""
-    ran_checks = False
-    if Path("copilot").exists():
-        click.secho("\nDetected a deployment repository", fg="blue")
-        deployment()
-        ran_checks = True
-
-    if not ran_checks:
-        click.secho("Could not find a deployment repository, no checks to run.", fg="red")
-        exit(1)
-
-
-def deployment():
-    click.secho()
-
-    compatible = True
-    platform_helper_version_status = get_platform_helper_version_status()
-    ClickIOProvider().process_messages(platform_helper_version_status.validate())
-    copilot_versions = tool_versioning.get_copilot_versions()
-    aws_versions = tool_versioning.get_aws_versions()
-    _check_tool_versions(platform_helper_version_status, copilot_versions, aws_versions)
-    click.secho("Checking addons templates versions...", fg="blue")
-
-    local_version = platform_helper_version_status.installed
-    latest_release = platform_helper_version_status.latest
-    addons_templates_table = PrettyTable()
-    addons_templates_table.field_names = [
-        "Addons Template File",
-        "Generated with",
-        "Compatible with local?",
-        "Compatible with latest?",
-    ]
-    addons_templates_table.align["Addons Template File"] = "l"
-
-    addons_templates = list(Path("./copilot").glob("**/addons/*"))
-    # Sort by template file path
-    addons_templates.sort(key=lambda e: str(e))
-    # Bring environment addons to the top
-    addons_templates.sort(key=lambda e: "environments/" not in str(e))
-
-    recommendations = {}
-
-    ConfigProvider().config_file_check()
-
-    for template_file in addons_templates:
-        generated_with_version = maybe
-        local_compatible_symbol = yes
-        latest_compatible_symbol = yes
-
-        try:
-            generated_with_version = tool_versioning.get_template_generated_with_version(
-                str(template_file.resolve())
-            )
-            tool_versioning.validate_template_version(local_version, str(template_file.resolve()))
-        except IncompatibleMajorVersionException:
-            local_compatible_symbol = no
-            compatible = False
-            recommendations["dbt-platform-helper-upgrade"] = RECOMMENDATIONS[
-                "dbt-platform-helper-upgrade"
-            ].format(version=latest_release)
-            recommendations["dbt-platform-helper-upgrade-note"] = RECOMMENDATIONS[
-                "dbt-platform-helper-upgrade-note"
-            ]
-        except ValidationException:
-            local_compatible_symbol = maybe
-            compatible = False
-            recommendations["dbt-platform-helper-upgrade"] = RECOMMENDATIONS[
-                "dbt-platform-helper-upgrade"
-            ].format(version=latest_release)
-            recommendations["dbt-platform-helper-upgrade-note"] = RECOMMENDATIONS[
-                "dbt-platform-helper-upgrade-note"
-            ]
-
-        try:
-            generated_with_version = tool_versioning.get_template_generated_with_version(
-                str(template_file.resolve())
-            )
-            tool_versioning.validate_template_version(latest_release, str(template_file.resolve()))
-        except IncompatibleMajorVersionException:
-            latest_compatible_symbol = no
-            compatible = False
-        except ValidationException:
-            latest_compatible_symbol = maybe
-            compatible = False
-
-        addons_templates_table.add_row(
-            [
-                template_file.relative_to("."),
-                (maybe if latest_compatible_symbol is maybe else str(generated_with_version)),
-                local_compatible_symbol,
-                latest_compatible_symbol,
-            ]
-        )
-
-    click.secho(addons_templates_table)
-    render_recommendations(recommendations)
-
-    exit(0 if compatible else 1)
-
-
-def _check_tool_versions(platform_helper_versions, copilot_versions, aws_versions):
-    click.secho("Checking tooling versions...", fg="blue")
-    recommendations = {}
-
-    local_copilot_version = copilot_versions.installed
-    copilot_latest_release = copilot_versions.latest
-    if local_copilot_version is None:
-        recommendations["install-copilot"] = (
-            "Install AWS Copilot https://aws.github.io/copilot-cli/"
-        )
-
-    if aws_versions.installed is None:
-        recommendations["install-aws"] = "Install AWS CLI https://aws.amazon.com/cli/"
-
-    tool_versions_table = PrettyTable()
-    tool_versions_table.field_names = [
-        "Tool",
-        "Local version",
-        "Released version",
-        "Running latest?",
-    ]
-    tool_versions_table.align["Tool"] = "l"
-
-    tool_versions_table.add_row(
-        [
-            "aws",
-            str(aws_versions.installed),
-            str(aws_versions.latest),
-            no if aws_versions.is_outdated() else yes,
-        ]
-    )
-    tool_versions_table.add_row(
-        [
-            "copilot",
-            str(copilot_versions.installed),
-            str(copilot_versions.latest),
-            no if copilot_versions.is_outdated() else yes,
-        ]
-    )
-    tool_versions_table.add_row(
-        [
-            "dbt-platform-helper",
-            str(platform_helper_versions.installed),
-            str(platform_helper_versions.latest),
-            no if platform_helper_versions.is_outdated() else yes,
-        ]
-    )
-
-    click.secho(tool_versions_table)
-
-    if aws_versions.is_outdated() and "install-aws" not in recommendations:
-        recommendations["aws-upgrade"] = RECOMMENDATIONS["generic-tool-upgrade"].format(
-            tool="AWS CLI",
-            version=str(aws_versions.latest),
-        )
-
-    if copilot_versions.is_outdated() and "install-copilot" not in recommendations:
-        recommendations["copilot-upgrade"] = RECOMMENDATIONS["generic-tool-upgrade"].format(
-            tool="AWS Copilot",
-            version=str(copilot_latest_release),
-        )
-
-    if platform_helper_versions.is_outdated():
-        recommendations["dbt-platform-helper-upgrade"] = RECOMMENDATIONS[
-            "dbt-platform-helper-upgrade"
-        ].format(version=str(platform_helper_versions.latest))
-        recommendations["dbt-platform-helper-upgrade-note"] = RECOMMENDATIONS[
-            "dbt-platform-helper-upgrade-note"
-        ]
-
-    render_recommendations(recommendations)
-
-
-def render_recommendations(recommendations: Dict[str, str]):
-    if recommendations:
-        click.secho("\nRecommendations:\n", bold=True)
-
-        for name, recommendation in recommendations.items():
-            if name.endswith("-note"):
-                continue
-            click.secho(f"  - {recommendation}")
-            if recommendations.get(f"{name}-note", False):
-                click.secho(f"    {recommendations.get(f'{name}-note')}")
-
-        click.secho()
+    try:
+        Config().validate()
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))
 
 
 @config.command()
@@ -256,85 +31,8 @@ def aws(file_path):
 
     If no `--file-path` is specified, defaults to `~/.aws/config`.
     """
-    sso_oidc_client = boto3.client("sso-oidc", region_name="eu-west-2")
-    sso_client = boto3.client("sso", region_name="eu-west-2")
-    oidc_app = create_oidc_application(sso_oidc_client)
-    verification_url, device_code = get_device_code(sso_oidc_client, oidc_app, SSO_START_URL)
-
-    if click.confirm(
-        "You are about to be redirected to a verification page. You will need to complete sign-in before returning to the command line. Do you want to continue?",
-        abort=True,
-    ):
-        webbrowser.open(verification_url)
-
-    if click.confirm("Have you completed the sign-in process in your browser?", abort=True):
-        access_token = get_access_token(device_code, sso_oidc_client, oidc_app)
-
-    aws_config_path = os.path.expanduser(file_path)
-
-    if click.confirm(
-        f"This command is destructive and will overwrite file contents at {file_path}. Are you sure you want to continue?",
-        abort=True,
-    ):
-        with open(aws_config_path, "w") as config_file:
-            config_file.write(AWS_CONFIG)
-
-            for account in retrieve_aws_accounts(sso_client, access_token):
-                config_file.write(f"[profile {account['accountName']}]\n")
-                config_file.write("sso_session = uktrade\n")
-                config_file.write(f"sso_account_id = {account['accountId']}\n")
-                config_file.write("sso_role_name = AdministratorAccess\n")
-                config_file.write("region = eu-west-2\n")
-                config_file.write("output = json\n")
-                config_file.write("\n")
-
-
-def create_oidc_application(sso_oidc_client):
-    print("Creating temporary AWS SSO OIDC application")
-    client = sso_oidc_client.register_client(
-        clientName="platform-helper",
-        clientType="public",
-    )
-    client_id = client.get("clientId")
-    client_secret = client.get("clientSecret")
-
-    return client_id, client_secret
-
-
-def get_device_code(sso_oidc_client, oidc_application, start_url):
-    print("Initiating device code flow")
-    authz = sso_oidc_client.start_device_authorization(
-        clientId=oidc_application[0],
-        clientSecret=oidc_application[1],
-        startUrl=start_url,
-    )
-    url = authz.get("verificationUriComplete")
-    deviceCode = authz.get("deviceCode")
-
-    return url, deviceCode
-
-
-def retrieve_aws_accounts(sso_client, aws_sso_token):
-    aws_accounts_response = sso_client.list_accounts(
-        accessToken=aws_sso_token,
-        maxResults=100,
-    )
-    if len(aws_accounts_response.get("accountList", [])) == 0:
-        raise RuntimeError("Unable to retrieve AWS SSO account list\n")
-    return aws_accounts_response.get("accountList")
-
-
-def get_access_token(device_code, sso_oidc_client, oidc_app):
     try:
-        token_response = sso_oidc_client.create_token(
-            clientId=oidc_app[0],
-            clientSecret=oidc_app[1],
-            grantType="urn:ietf:params:oauth:grant-type:device_code",
-            deviceCode=device_code,
-        )
-
-        return token_response.get("accessToken")
-
-    except botocore.exceptions.ClientError as e:
-        if e.response["Error"]["Code"] != "AuthorizationPendingException":
-            raise e
+        session = get_aws_session_or_abort()
+        Config(sso=SSOAuthProvider(session)).generate_aws(file_path)
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))

dbt_platform_helper/commands/copilot.py

@@ -10,13 +10,10 @@ from dbt_platform_helper.providers.config_validator import ConfigValidator
 from dbt_platform_helper.providers.files import FileProvider
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.kms import KMSProvider
+from dbt_platform_helper.providers.parameter_store import ParameterStore
 from dbt_platform_helper.utils.aws import get_aws_session_or_abort
 from dbt_platform_helper.utils.click import ClickDocOptGroup
 
-# TODOs
-# Figure out a pattern for copilot templating and the new copilot domain - probably a lot of overlap here that really belongs in the copilottemplating domain instead (atleast whatever is concerned with "templating")
-# Check for E2E test coverage.
-
 
 @click.group(chain=True, cls=ClickDocOptGroup)
 def copilot():
@@ -28,8 +25,15 @@ def make_addons():
     """Generate addons CloudFormation for each environment."""
     try:
         session = get_aws_session_or_abort()
+        parameter_provider = ParameterStore(session.client("ssm"))
         config_provider = ConfigProvider(ConfigValidator())
-        kms_provider = KMSProvider(session.client("kms"))
-        Copilot(config_provider, FileProvider(), CopilotTemplating(), kms_provider).make_addons()
+        Copilot(
+            config_provider,
+            parameter_provider,
+            FileProvider(),
+            CopilotTemplating(),
+            KMSProvider,
+            session,
+        ).make_addons()
     except Exception as err:
         ClickIOProvider().abort_with_error(str(err))

dbt_platform_helper/commands/database.py

@@ -2,6 +2,8 @@ import click
 
 from dbt_platform_helper.commands.environment import AVAILABLE_TEMPLATES
 from dbt_platform_helper.domain.database_copy import DatabaseCopy
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.utils.click import ClickDocOptGroup
 
 
@@ -38,9 +40,11 @@ def database():
 )
 def dump(app, from_env, database, from_vpc, filename):
     """Dump a database into an S3 bucket."""
-    data_copy = DatabaseCopy(app, database)
-    data_copy.dump(from_env, from_vpc, filename)
-    # Todo: Catch expected errors and output message
+    try:
+        data_copy = DatabaseCopy(app, database)
+        data_copy.dump(from_env, from_vpc, filename)
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))
 
 
 @database.command(name="load")
@@ -68,9 +72,11 @@ def dump(app, from_env, database, from_vpc, filename):
 )
 def load(app, to_env, database, to_vpc, auto_approve, filename):
     """Load a database from an S3 bucket."""
-    data_copy = DatabaseCopy(app, database, auto_approve)
-    data_copy.load(to_env, to_vpc, filename)
-    # Todo: Catch expected errors and output message
+    try:
+        data_copy = DatabaseCopy(app, database, auto_approve)
+        data_copy.load(to_env, to_vpc, filename)
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))
 
 
 @database.command(name="copy")
@@ -120,6 +126,8 @@ def copy(
     no_maintenance_page,
 ):
     """Copy a database between environments."""
-    data_copy = DatabaseCopy(app, database, auto_approve)
-    data_copy.copy(from_env, to_env, from_vpc, to_vpc, svc, template, no_maintenance_page)
-    # Todo: Catch expected errors and output message
+    try:
+        data_copy = DatabaseCopy(app, database, auto_approve)
+        data_copy.copy(from_env, to_env, from_vpc, to_vpc, svc, template, no_maintenance_page)
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))

dbt_platform_helper/commands/environment.py

@@ -94,9 +94,8 @@ def generate(name):
 def generate_terraform(name, terraform_platform_modules_version):
     click_io = ClickIOProvider()
     try:
-        # TODO = pass the session to ConfigValidator
-        get_aws_session_or_abort()
-        config_provider = ConfigProvider(ConfigValidator())
+        session = get_aws_session_or_abort()
+        config_provider = ConfigProvider(ConfigValidator(session=session))
         TerraformEnvironment(config_provider).generate(name, terraform_platform_modules_version)
     except PlatformException as err:
         click_io.abort_with_error(str(err))

dbt_platform_helper/domain/codebase.py

@@ -11,6 +11,7 @@ from boto3 import Session
 from dbt_platform_helper.platform_exception import PlatformException
 from dbt_platform_helper.providers.files import FileProvider
 from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.parameter_store import ParameterStore
 from dbt_platform_helper.utils.application import Application
 from dbt_platform_helper.utils.application import (
     ApplicationEnvironmentNotFoundException,
@@ -32,6 +33,7 @@ from dbt_platform_helper.utils.template import setup_templates
 class Codebase:
     def __init__(
         self,
+        parameter_provider: ParameterStore,
         io: ClickIOProvider = ClickIOProvider(),
         load_application: Callable[[str], Application] = load_application,
         get_aws_session_or_abort: Callable[[str], Session] = get_aws_session_or_abort,
@@ -50,6 +52,7 @@ class Codebase:
         check_if_commit_exists: Callable[[str], str] = check_if_commit_exists,
         run_subprocess: Callable[[str], str] = subprocess.run,
     ):
+        self.parameter_provider = parameter_provider
         self.io = io
         self.load_application = load_application
         self.get_aws_session_or_abort = get_aws_session_or_abort
@@ -190,9 +193,8 @@ class Codebase:
         """List available codebases for the application."""
         session = self.get_aws_session_or_abort()
         application = self.load_application(app, session)
-        ssm_client = session.client("ssm")
         ecr_client = session.client("ecr")
-        codebases = self.__get_codebases(application, ssm_client)
+        codebases = self.__get_codebases(application, session.client("ssm"))
 
         self.io.info("The following codebases are available:")
 
@@ -209,11 +211,9 @@ class Codebase:
         self.io.info("")
 
     def __get_codebases(self, application, ssm_client):
-        parameters = ssm_client.get_parameters_by_path(
-            Path=f"/copilot/applications/{application.name}/codebases",
-            Recursive=True,
-        )["Parameters"]
-
+        parameters = self.parameter_provider.get_ssm_parameters_by_path(
+            f"/copilot/applications/{application.name}/codebases"
+        )
         codebases = [json.loads(p["Value"]) for p in parameters]
 
         if not codebases: