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

dbt_platform_helper/commands/internal.py

@@ -0,0 +1,140 @@
+import click
+
+from dbt_platform_helper.domain.service import ServiceManager
+from dbt_platform_helper.domain.update_alb_rules import UpdateALBRules
+from dbt_platform_helper.domain.versioning import PlatformHelperVersioning
+from dbt_platform_helper.platform_exception import PlatformException
+from dbt_platform_helper.providers.autoscaling import AutoscalingProvider
+from dbt_platform_helper.providers.config import ConfigProvider
+from dbt_platform_helper.providers.config_validator import ConfigValidator
+from dbt_platform_helper.providers.ecs import ECS
+from dbt_platform_helper.providers.io import ClickIOProvider
+from dbt_platform_helper.providers.logs import LogsProvider
+from dbt_platform_helper.providers.s3 import S3Provider
+from dbt_platform_helper.utils.application import load_application
+from dbt_platform_helper.utils.aws import get_aws_session_or_abort
+from dbt_platform_helper.utils.click import ClickDocOptGroup
+
+
+@click.group(cls=ClickDocOptGroup)
+def internal():
+    """Internal commands for use within pipelines or by Platform Team."""
+
+
+@internal.command()
+def migrate_service_manifests():
+    """Migrate copilot manifests to service manifests."""
+    click_io = ClickIOProvider()
+
+    try:
+        service_manager = ServiceManager()
+        service_manager.migrate_copilot_manifests()
+    except PlatformException as error:
+        click_io.abort_with_error(str(error))
+
+
+@internal.group(cls=ClickDocOptGroup)
+def service():
+    """Subgroup for 'internal service' commands."""
+
+
+@service.command(help="Trigger an ECS deployment.")
+@click.option("--name", required=True, help="The name of the ECS service to create or update.")
+@click.option(
+    "--env",
+    required=True,
+    help="The name of the environment where the ECS service will be created or updated.",
+)
+@click.option(
+    "--image-tag",
+    required=True,
+    help="Image tag to deploy for the service(s). Takes precedence over the $IMAGE_TAG environment variable.",
+)
+def deploy(name, env, image_tag):
+    """Register a new ECS task definition from an S3 JSON template, update the
+    ECS service, and tail CloudWatch logs until the ECS rollout is complete."""
+    click_io = ClickIOProvider()
+
+    try:
+
+        config = ConfigProvider(ConfigValidator()).get_enriched_config()
+        application_name = config.get("application", "")
+        application = load_application(app=application_name, env=env)
+
+        ecs_client = application.environments[env].session.client("ecs")
+        ssm_client = application.environments[env].session.client("ssm")
+        s3_client = application.environments[env].session.client("s3")
+        logs_client = application.environments[env].session.client("logs")
+        autoscaling_client = application.environments[env].session.client("application-autoscaling")
+
+        ecs_provider = ECS(
+            ecs_client=ecs_client,
+            ssm_client=ssm_client,
+            application_name=application.name,
+            env=env,
+        )
+        s3_provider = S3Provider(client=s3_client)
+        logs_provider = LogsProvider(client=logs_client)
+        autoscaling_provider = AutoscalingProvider(client=autoscaling_client)
+
+        service_manager = ServiceManager(
+            ecs_provider=ecs_provider,
+            s3_provider=s3_provider,
+            logs_provider=logs_provider,
+            autoscaling_provider=autoscaling_provider,
+        )
+        service_manager.deploy(
+            service=name,
+            environment=env,
+            application=application.name,
+            image_tag=image_tag,
+        )
+    except PlatformException as error:
+        click_io.abort_with_error(str(error))
+
+
+@service.command(help="Generate Terraform manifest for the specified service(s).")
+@click.option(
+    "--name",
+    required=False,
+    help="The name of the service(s) to generate service manifest(s) for.",
+    multiple=True,
+)
+@click.option(
+    "--env",
+    required=True,
+    help="The name of the environment to generate service manifests for.",
+)
+def generate(name, env):
+    """Validates the service-config.yml format, applies the environment-specific
+    overrides, and generates a Terraform manifest at
+    /terraform/services/<environment>/<service>/main.tf.json."""
+
+    services = list(name)
+    click_io = ClickIOProvider()
+
+    try:
+        service_manager = ServiceManager()
+        service_manager.generate(environment=env, services=services)
+
+    except PlatformException as err:
+        click_io.abort_with_error(str(err))
+
+
+@internal.group(cls=ClickDocOptGroup)
+def alb():
+    """Load Balancer related commands."""
+    PlatformHelperVersioning().check_if_needs_update()
+
+
+@alb.command()
+@click.option("--env", type=str, required=True)
+def update_rules(env: str):
+    """Update alb rules based on service-deployment-mode for a given
+    environment."""
+    try:
+        session = get_aws_session_or_abort()
+        update_aws = UpdateALBRules(session)
+        update_aws.update_alb_rules(environment=env)
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))

dbt_platform_helper/commands/notify.py

@@ -1,21 +1,21 @@
 import click
-from slack_sdk import WebClient
-from slack_sdk.models import blocks
 
-from dbt_platform_helper.utils.arn_parser import ARN
+from dbt_platform_helper.domain.notify import Notify
+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.slack_channel_notifier import SlackChannelNotifier
 from dbt_platform_helper.utils.click import ClickDocOptGroup
-from dbt_platform_helper.utils.versioning import (
-    check_platform_helper_version_needs_update,
-)
 
 
 @click.group(cls=ClickDocOptGroup, help="Send Slack notifications")
 def notify():
-    check_platform_helper_version_needs_update()
+    PlatformHelperVersioning().check_if_needs_update()
 
 
 @notify.command(
-    help="Send environment progress notifications. This creates (or updates if --slack-ref is provided) the top level message to the channel."
+    help="Send environment progress notifications. This creates (or updates if --slack-ref is provided) the top level message to the channel.",
+    deprecated=True,
 )
 @click.argument("slack-channel-id")
 @click.argument("slack-token")
@@ -24,7 +24,9 @@ def notify():
 @click.option("--repository")
 @click.option("--commit-sha")
 @click.option("--slack-ref", help="Slack message reference of the message to update")
+@click.pass_context
 def environment_progress(
+    ctx,
     slack_channel_id: str,
     slack_token: str,
     message: str,
@@ -33,56 +35,52 @@ def environment_progress(
     commit_sha: str,
     slack_ref: str,
 ):
-    args = _get_slack_args(build_arn, commit_sha, message, repository, slack_channel_id)
-    slack = _get_slack_client(slack_token)
-
-    if slack_ref:
-        response = slack.chat_update(ts=slack_ref, **args)
-    else:
-        response = slack.chat_postMessage(ts=slack_ref, **args)
 
-    print(response["ts"])
+    ctx.invoke(
+        post_message,
+        slack_channel_id=slack_channel_id,
+        slack_token=slack_token,
+        message=message,
+        build_arn=build_arn,
+        repository=repository,
+        commit_sha=commit_sha,
+        slack_ref=slack_ref,
+    )
 
 
-def _get_slack_args(
-    build_arn: str, commit_sha: str, message: str, repository: str, slack_channel_id: str
+@notify.command(
+    help="Send Slack notifications. This creates (or updates if --slack-ref is provided) the top level message to the channel."
+)
+@click.argument("slack-channel-id")
+@click.argument("slack-token")
+@click.argument("message")
+@click.option("--build-arn")
+@click.option("--repository")
+@click.option("--commit-sha")
+@click.option("--slack-ref", help="Slack message reference of the message to update")
+def post_message(
+    slack_channel_id: str,
+    slack_token: str,
+    message: str,
+    build_arn: str,
+    repository: str,
+    commit_sha: str,
+    slack_ref: str,
 ):
-    context_elements = []
-    if repository:
-        context_elements.append(f"*Repository*: <https://github.com/{repository}|{repository}>")
-        if commit_sha:
-            context_elements.append(
-                f"*Revision*: <https://github.com/{repository}/commit/{commit_sha}|{commit_sha}>"
-            )
-    if build_arn:
-        context_elements.append(f"<{get_build_url(build_arn)}|Build Logs>")
-    message_blocks = [
-        blocks.SectionBlock(
-            text=blocks.TextObject(type="mrkdwn", text=message),
-        ),
-    ]
-
-    if context_elements:
-        message_blocks.append(
-            blocks.ContextBlock(
-                elements=[
-                    blocks.TextObject(type="mrkdwn", text=element) for element in context_elements
-                ]
-            )
+    try:
+        io = ClickIOProvider()
+        slack_notifier = SlackChannelNotifier(slack_token, slack_channel_id)
+        result = Notify(slack_notifier).post_message(
+            original_message_ref=slack_ref,
+            message=message,
+            build_arn=build_arn,
+            repository=repository,
+            commit_sha=commit_sha,
         )
 
-    args = {
-        "channel": slack_channel_id,
-        "blocks": message_blocks,
-        "text": message,
-        "unfurl_links": False,
-        "unfurl_media": False,
-    }
-    return args
-
-
-def _get_slack_client(token: str):
-    return WebClient(token=token)
+        io.info(result)
+    except PlatformException as err:
+        io.abort_with_error(str(err))
 
 
 @notify.command(help="Add a comment to an existing Slack message")
@@ -100,31 +98,13 @@ def add_comment(
     title: str,
     send_to_main_channel: bool,
 ):
-    slack = _get_slack_client(slack_token)
-
-    slack.chat_postMessage(
-        channel=slack_channel_id,
-        blocks=[blocks.SectionBlock(text=blocks.TextObject(type="mrkdwn", text=message))],
-        text=title if title else message,
-        reply_broadcast=send_to_main_channel,
-        unfurl_links=False,
-        unfurl_media=False,
-        thread_ts=slack_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,
+        slack_notifier = SlackChannelNotifier(slack_token, slack_channel_id)
+        Notify(slack_notifier).add_comment(
+            message=message,
+            title=title,
+            reply_broadcast=send_to_main_channel,
+            original_message_ref=slack_ref,
         )
-    except ValueError:
-        return ""
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))

dbt_platform_helper/commands/pipeline.py

@@ -1,35 +1,28 @@
 #!/usr/bin/env python
 import click
 
-from dbt_platform_helper.constants import DEFAULT_TERRAFORM_PLATFORM_MODULES_VERSION
 from dbt_platform_helper.domain.pipelines import Pipelines
+from dbt_platform_helper.domain.versioning import PlatformHelperVersioning
 from dbt_platform_helper.providers.config import ConfigProvider
 from dbt_platform_helper.providers.config_validator import ConfigValidator
 from dbt_platform_helper.providers.ecr import ECRProvider
+from dbt_platform_helper.providers.environment_variable import (
+    EnvironmentVariableProvider,
+)
+from dbt_platform_helper.providers.files import FileProvider
 from dbt_platform_helper.providers.io import ClickIOProvider
 from dbt_platform_helper.providers.terraform_manifest import TerraformManifestProvider
-from dbt_platform_helper.utils.aws import get_codestar_connection_arn
 from dbt_platform_helper.utils.click import ClickDocOptGroup
 from dbt_platform_helper.utils.git import git_remote
-from dbt_platform_helper.utils.versioning import (
-    check_platform_helper_version_needs_update,
-)
 
 
 @click.group(chain=True, cls=ClickDocOptGroup)
 def pipeline():
     """Pipeline commands."""
-    check_platform_helper_version_needs_update()
+    PlatformHelperVersioning().check_if_needs_update()
 
 
 @pipeline.command()
-@click.option(
-    "--terraform-platform-modules-version",
-    help=f"""Override the default version of terraform-platform-modules with a specific version or branch. 
-    Precedence of version used is version supplied via CLI, then the version found in 
-    platform-config.yml/default_versions/terraform-platform-modules. 
-    In absence of these inputs, defaults to version '{DEFAULT_TERRAFORM_PLATFORM_MODULES_VERSION}'.""",
-)
 @click.option(
     "--deploy-branch",
     help="""Specify the branch of <application>-deploy used to configure the source stage in the environment-pipeline resource. 
@@ -38,29 +31,40 @@ def pipeline():
     <application>-deploy/platform-config.yml/environment_pipelines/<environment-pipeline>/branch).""",
     default=None,
 )
-def generate(terraform_platform_modules_version: str, deploy_branch: str):
+def generate(deploy_branch: str):
     """
     Given a platform-config.yml file, generate environment and service
     deployment pipelines.
 
     This command does the following in relation to the environment pipelines:
-    - Reads contents of `platform-config.yml/environment-pipelines` configuration.
+    - Reads contents of `platform-config.yml/environment_pipelines` configuration.
       The `terraform/environment-pipelines/<aws_account>/main.tf` file is generated using this configuration.
       The `main.tf` file is then used to generate Terraform for creating an environment pipeline resource.
 
     This command does the following in relation to the codebase pipelines:
-    - Generates the copilot pipeline manifest.yml for copilot/pipelines/<codebase_pipeline_name>
+    - Reads contents of `platform-config.yml/codebase_pipelines` configuration.
+      The `terraform/codebase-pipelines/main.tf.json` file is generated using this configuration.
+      The `main.tf.json` file is then used to generate Terraform for creating a codebase pipeline resource.
     """
+    config_provider = ConfigProvider(ConfigValidator())
+    environment_variable_provider = EnvironmentVariableProvider()
     io = ClickIOProvider()
+    platform_helper_versioning = PlatformHelperVersioning(
+        io,
+        config_provider,
+        environment_variable_provider,
+    )
+
     try:
         pipelines = Pipelines(
-            ConfigProvider(ConfigValidator()),
+            config_provider,
             TerraformManifestProvider(),
             ECRProvider(),
             git_remote,
-            get_codestar_connection_arn,
             io,
+            FileProvider(),
+            platform_helper_versioning,
         )
-        pipelines.generate(terraform_platform_modules_version, deploy_branch)
+        pipelines.generate(deploy_branch)
     except Exception as exc:
         io.abort_with_error(str(exc))

dbt_platform_helper/commands/secrets.py

@@ -1,120 +1,66 @@
 #!/usr/bin/env python
 
-from pathlib import Path
 
 import click
-from botocore.exceptions import ClientError
-from cloudfoundry_client.client import CloudFoundryClient
-
-from dbt_platform_helper.utils.application import get_application_name
-from dbt_platform_helper.utils.aws import SSM_BASE_PATH
-from dbt_platform_helper.utils.aws import get_aws_session_or_abort
-from dbt_platform_helper.utils.aws import get_ssm_secrets
-from dbt_platform_helper.utils.aws import set_ssm_param
+
+from dbt_platform_helper.domain.secrets import Secrets
+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.utils.click import ClickDocOptGroup
-from dbt_platform_helper.utils.versioning import (
-    check_platform_helper_version_needs_update,
-)
 
 
 def secret_should_be_skipped(secret_name):
     return "AWS_" in secret_name
 
 
-def get_paas_env_vars(client: CloudFoundryClient, paas: str) -> dict:
-    org, space, app = paas.split("/")
-
-    env_vars = None
-
-    for paas_org in client.v2.organizations:
-        if paas_org["entity"]["name"] == org:
-            for paas_space in paas_org.spaces():
-                if paas_space["entity"]["name"] == space:
-                    for paas_app in paas_space.apps():
-                        if paas_app["entity"]["name"] == app:
-                            env_vars = paas_app["entity"]["environment_json"]
-
-    if not env_vars:
-        raise Exception(f"Application {paas} not found")
+@click.group(chain=True, cls=ClickDocOptGroup)
+def secrets():
+    PlatformHelperVersioning().check_if_needs_update()
 
-    return dict(env_vars)
 
+@secrets.command()
+@click.option("--app", help="Application name.", required=True)
+@click.option("--name", help="Secret name (automatically uppercased).", required=True)
+@click.option(
+    "--overwrite",
+    is_flag=True,
+    default=False,
+    help="Allows overwriting the value of secrets if they already exist.",
+)
+def create(app: str, name: str, overwrite: bool):
+    """Create a Parameter Store secret for all environments of an
+    application."""
 
-@click.group(chain=True, cls=ClickDocOptGroup)
-def secrets():
-    check_platform_helper_version_needs_update()
+    try:
+        Secrets().create(app, name, overwrite)
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))
 
 
 @secrets.command()
-@click.argument("source_environment")
-@click.argument("target_environment")
-@click.option("--project-profile", required=True, help="AWS account profile name")
-def copy(project_profile, source_environment, target_environment):
-    """Copy secrets from one environment to a new environment."""
-    get_aws_session_or_abort(project_profile)
-
-    if not Path(f"copilot/environments/{target_environment}").exists():
-        click.echo(f"""Target environment manifest for "{target_environment}" does not exist.""")
-        exit(1)
-
-    app_name = get_application_name()
-    secrets = get_ssm_secrets(app_name, source_environment)
-
-    for secret in secrets:
-        secret_name = secret[0].replace(f"/{source_environment}/", f"/{target_environment}/")
-
-        if secret_should_be_skipped(secret_name):
-            continue
-
-        click.echo(secret_name)
-
-        try:
-            set_ssm_param(
-                app_name,
-                target_environment,
-                secret_name,
-                secret[1],
-                False,
-                False,
-                f"Copied from {source_environment} environment.",
-            )
-        except ClientError as e:
-            if e.response["Error"]["Code"] == "ParameterAlreadyExists":
-                click.secho(
-                    f"""The "{secret_name.split("/")[-1]}" parameter already exists for the "{target_environment}" environment.""",
-                    fg="yellow",
-                )
-            else:
-                raise e
+@click.option("--app", help="Application name.", required=True)
+@click.option("--source", help="Source environment where to copy secrets from.", required=True)
+@click.option("--target", help="Destination environment where to copy secrets to.", required=True)
+def copy(app, source, target):
+    """Copy secrets from one environment to another."""
+
+    try:
+        Secrets().copy(app, source, target)
+    except PlatformException as err:
+        ClickIOProvider().abort_with_error(str(err))
 
 
 @secrets.command()
 @click.argument("app", type=str, required=True)
 @click.argument("env", type=str, required=True)
 def list(app, env):
-    """List secret names and values for an environment."""
-
-    session = get_aws_session_or_abort()
-    client = session.client("ssm")
-
-    path = SSM_BASE_PATH.format(app=app, env=env)
-
-    params = dict(Path=path, Recursive=False, WithDecryption=True, MaxResults=10)
-    secrets = []
-
-    while True:
-        response = client.get_parameters_by_path(**params)
-
-        for secret in response["Parameters"]:
-            secrets.append(f"{secret['Name']:<8}: {secret['Value']:<15}")
-
-        if "NextToken" in response:
-            params["NextToken"] = response["NextToken"]
-        else:
-            break
+    """[DELETED] List secret names and values for an environment."""
 
-    # Todo: When we refactor this, the above could probably just use dbt_platform_helper.utils.aws.get_ssm_secret_names so we would end up with print("\n".join(get_ssm_secret_names(app, env)))
-    print("\n".join(sorted(secrets)))
+    click.secho(
+        message="\nThis command has been removed to prevent accidental exposure of secret values in local terminals and logs. To view secrets, log into your AWS account and head over to AWS Parameter Store https://eu-west-2.console.aws.amazon.com/systems-manager/parameters/\n",
+        fg="magenta",
+    )
 
 
 if __name__ == "__main__":

dbt_platform_helper/commands/version.py

@@ -1,9 +1,9 @@
 import click
 
+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.utils.click import ClickDocOptGroup
-from dbt_platform_helper.utils.versioning import RequiredVersion
 
 
 @click.group(chain=True, cls=ClickDocOptGroup)
@@ -21,17 +21,12 @@ def version():
 )
 def get_platform_helper_for_project(pipeline):
     """
-    Version precedence is in this order:
-        - if the --pipeline option is supplied, the version in 'platform-config.yml' in:
-            environment_pipelines:
-                <pipeline>:
-                    ...
-                    versions:
-                        platform-helper
-        - The version from default_versions/platform-helper in 'platform-config.yml'
-        - Fall back on the version in the deprecated '.platform-helper-version' file
+    Deprecated: Required in pipelines for projects running platform-helper < 14.0.0.
+
+    Version preferences removed, requires specifying platform-helper version in platform-config.yml
     """
+    io = ClickIOProvider()
     try:
-        RequiredVersion().get_required_version(pipeline)
+        io.info(PlatformHelperVersioning().get_required_version())
     except PlatformException as err:
-        ClickIOProvider().abort_with_error(str(err))
+        io.abort_with_error(str(err))

dbt_platform_helper/constants.py

@@ -1,11 +1,39 @@
-# Todo: Move to Config provider
+# TODO: DBTP-1888: Move to Config provider
+REPO_ORG = "uktrade"
 PLATFORM_CONFIG_FILE = "platform-config.yml"
-# Todo: Can we get rid of this yet?
-PLATFORM_HELPER_VERSION_FILE = ".platform-helper-version"
-# Todo: Move to ???
-DEFAULT_TERRAFORM_PLATFORM_MODULES_VERSION = "7"
-SUPPORTED_TERRAFORM_VERSION = "~> 1.8"
-SUPPORTED_AWS_PROVIDER_VERSION = "~> 5"
+SERVICE_DIRECTORY = "services"
+SERVICE_CONFIG_FILE = "service-config.yml"
+ENVIRONMENT_PIPELINE_MODULE_PATH = (
+    "git::git@github.com:uktrade/platform-tools.git//terraform/environment-pipelines?depth=1&ref="
+)
+
+CODEBASE_PIPELINE_MODULE_PATH = (
+    "git::git@github.com:uktrade/platform-tools.git//terraform/codebase-pipelines?depth=1&ref="
+)
+EXTENSIONS_MODULE_PATH = (
+    "git::git@github.com:uktrade/platform-tools.git//terraform/extensions?depth=1&ref="
+)
+PLATFORM_HELPER_VERSION_OVERRIDE_KEY = "PLATFORM_HELPER_VERSION_OVERRIDE"
+TERRAFORM_EXTENSIONS_MODULE_SOURCE_OVERRIDE_ENV_VAR = "TERRAFORM_EXTENSIONS_MODULE_SOURCE_OVERRIDE"
+TERRAFORM_ENVIRONMENT_PIPELINES_MODULE_SOURCE_OVERRIDE_ENV_VAR = (
+    "TERRAFORM_ENVIRONMENT_PIPELINES_MODULE_SOURCE_OVERRIDE"
+)
+TERRAFORM_CODEBASE_PIPELINES_MODULE_SOURCE_OVERRIDE_ENV_VAR = (
+    "TERRAFORM_CODEBASE_PIPELINES_MODULE_SOURCE_OVERRIDE"
+)
+TERRAFORM_ECS_SERVICE_MODULE_SOURCE_OVERRIDE_ENV_VAR = (
+    "TERRAFORM_ECS_SERVICE_MODULE_SOURCE_OVERRIDE"
+)
+TERRAFORM_MODULE_SOURCE_TYPE_ENV_VAR = "TERRAFORM_MODULE_SOURCE_TYPE"  # "LOCAL", "SSH", "OVERRIDE"
+IMAGE_TAG_ENV_VAR = "IMAGE_TAG"
+PLATFORM_HELPER_PACKAGE_NAME = "dbt-platform-helper"
+SUPPORTED_TERRAFORM_VERSION = "~> 1.11"
+SUPPORTED_AWS_PROVIDER_VERSION = "~> 6"
+FIRST_UPGRADABLE_PLATFORM_HELPER_MAJOR_VERSION = 13
+
+MERGED_TPM_PLATFORM_HELPER_VERSION = 14
+PLATFORM_CONFIG_SCHEMA_VERSION = 1
+SERVICE_CONFIG_SCHEMA_VERSION = 1
 
 # Keys
 CODEBASE_PIPELINES_KEY = "codebase_pipelines"
@@ -28,3 +56,20 @@ SERVICE_NAME_SUFFIX = f"Service-{COPILOT_IDENTIFIER}"
 REFRESH_TOKEN_MESSAGE = (
     "To refresh this SSO session run `aws sso login` with the corresponding profile"
 )
+COPILOT_RULE_PRIORITY = 48000
+PLATFORM_RULE_STARTING_PRIORITY = 10000
+RULE_PRIORITY_INCREMENT = 100
+DUMMY_RULE_REASON = "DummyRule"
+MAINTENANCE_PAGE_TAGS = ["MaintenancePage", "AllowedIps", "BypassIpFilter", "AllowedSourceIps"]
+MAINTENANCE_PAGE_REASON = "MaintenancePage"
+MANAGED_BY_PLATFORM = "DBT Platform"
+MANAGED_BY_SERVICE_TERRAFORM = "DBT Platform - Service Terraform"
+MANAGED_BY_PLATFORM_TERRAFORM = "DBT Platform - Terraform"
+STANDARD_PLATFORM_SSO_ROLES = [
+    "AdministratorAccess",
+    "DBTPlatformDeveloperWrite",
+    "DBTPlatformDeveloperRead",
+]
+ROUTED_TO_PLATFORM_MODES = ["platform", "dual-deploy-platform-traffic"]
+ROUTED_TO_COPILOT_MODES = ["copilot", "dual-deploy-copilot-traffic"]
+HTTP_SERVICE_TYPES = ["Load Balanced Web Service"]