dbt-platform-helper 12.2.4__py3-none-any.whl → 12.3.0__py3-none-any.whl

dbt_platform_helper/commands/codebase.py

@@ -1,18 +1,8 @@
-import json
-import os
-
 import click
 
 from dbt_platform_helper.domain.codebase import Codebase
-from dbt_platform_helper.exceptions import ApplicationDeploymentNotTriggered
-from dbt_platform_helper.exceptions import ApplicationEnvironmentNotFoundError
-from dbt_platform_helper.exceptions import ApplicationNotFoundError
-from dbt_platform_helper.exceptions import CopilotCodebaseNotFoundError
-from dbt_platform_helper.exceptions import ImageNotFoundError
-from dbt_platform_helper.exceptions import NoCopilotCodebasesFoundError
-from dbt_platform_helper.exceptions import NotInCodeBaseRepositoryError
+from dbt_platform_helper.exceptions import PlatformException
 from dbt_platform_helper.utils.click import ClickDocOptGroup
-from dbt_platform_helper.utils.git import CommitNotFoundError
 from dbt_platform_helper.utils.versioning import (
     check_platform_helper_version_needs_update,
 )
@@ -29,12 +19,8 @@ def prepare():
     """Sets up an application codebase for use within a DBT platform project."""
     try:
         Codebase().prepare()
-    except NotInCodeBaseRepositoryError:
-        # TODO: Set exception message in the exceptions and just output the message in the command code
-        click.secho(
-            "You are in the deploy repository; make sure you are in the application codebase repository.",
-            fg="red",
-        )
+    except PlatformException as err:
+        click.secho(str(err), fg="red")
         raise click.Abort
 
 
@@ -50,17 +36,8 @@ def list(app, with_images):
     """List available codebases for the application."""
     try:
         Codebase().list(app, with_images)
-    except NoCopilotCodebasesFoundError:
-        click.secho(
-            f"""No codebases found for application "{app}""",
-            fg="red",
-        )
-        raise click.Abort
-    except ApplicationNotFoundError:
-        click.secho(
-            f"""The account "{os.environ.get("AWS_PROFILE")}" does not contain the application "{app}"; ensure you have set the environment variable "AWS_PROFILE" correctly.""",
-            fg="red",
-        )
+    except PlatformException as err:
+        click.secho(str(err), fg="red")
         raise click.Abort
 
 
@@ -76,23 +53,8 @@ def build(app, codebase, commit):
     """Trigger a CodePipeline pipeline based build."""
     try:
         Codebase().build(app, codebase, commit)
-    except ApplicationNotFoundError:
-        click.secho(
-            f"""The account "{os.environ.get("AWS_PROFILE")}" does not contain the application "{app}"; ensure you have set the environment variable "AWS_PROFILE" correctly.""",
-            fg="red",
-        )
-        raise click.Abort
-    except CommitNotFoundError:
-        click.secho(
-            f'The commit hash "{commit}" either does not exist or you need to run `git fetch`.',
-            fg="red",
-        )
-        raise click.Abort
-    except ApplicationDeploymentNotTriggered:
-        click.secho(
-            f"Your build for {codebase} was not triggered.",
-            fg="red",
-        )
+    except PlatformException as err:
+        click.secho(str(err), fg="red")
         raise click.Abort
 
 
@@ -108,39 +70,6 @@ def build(app, codebase, commit):
 def deploy(app, env, codebase, commit):
     try:
         Codebase().deploy(app, env, codebase, commit)
-    except ApplicationNotFoundError:
-        # TODO: Set exception message in the exceptions and just output the message in the command code
-        click.secho(
-            f"""The account "{os.environ.get("AWS_PROFILE")}" does not contain the application "{app}"; ensure you have set the environment variable "AWS_PROFILE" correctly.""",
-            fg="red",
-        )
-        raise click.Abort
-    except ApplicationEnvironmentNotFoundError:
-        click.secho(
-            f"""The environment "{env}" either does not exist or has not been deployed.""",
-            fg="red",
-        )
-        raise click.Abort
-    except (
-        CopilotCodebaseNotFoundError,
-        # TODO: Catch this error earlier and throw a more meaningful error, maybe it's CopilotCodebaseNotFoundError?
-        json.JSONDecodeError,
-    ):
-        click.secho(
-            f"""The codebase "{codebase}" either does not exist or has not been deployed.""",
-            fg="red",
-        )
-        raise click.Abort
-    except ImageNotFoundError:
-        click.secho(
-            f'The commit hash "{commit}" has not been built into an image, try the '
-            "`platform-helper codebase build` command first.",
-            fg="red",
-        )
-        raise click.Abort
-    except ApplicationDeploymentNotTriggered:
-        click.secho(
-            f"Your deployment for {codebase} was not triggered.",
-            fg="red",
-        )
+    except PlatformException as err:
+        click.secho(str(err), fg="red")
         raise click.Abort

dbt_platform_helper/commands/conduit.py

@@ -1,14 +1,10 @@
 import click
 
-from dbt_platform_helper.constants import CONDUIT_ADDON_TYPES
 from dbt_platform_helper.domain.conduit import Conduit
-from dbt_platform_helper.exceptions import AddonNotFoundError
-from dbt_platform_helper.exceptions import AddonTypeMissingFromConfigError
-from dbt_platform_helper.exceptions import CreateTaskTimeoutError
-from dbt_platform_helper.exceptions import InvalidAddonTypeError
-from dbt_platform_helper.exceptions import NoClusterError
-from dbt_platform_helper.exceptions import ParameterNotFoundError
-from dbt_platform_helper.providers.secrets import SecretNotFoundError
+from dbt_platform_helper.exceptions import AWSException
+from dbt_platform_helper.providers.cloudformation import CloudFormation
+from dbt_platform_helper.providers.ecs import ECS
+from dbt_platform_helper.providers.secrets import Secrets
 from dbt_platform_helper.utils.application import load_application
 from dbt_platform_helper.utils.click import ClickDocOptCommand
 from dbt_platform_helper.utils.versioning import (
@@ -35,44 +31,28 @@ def conduit(addon_name: str, app: str, env: str, access: str):
     application = load_application(app)
 
     try:
-        Conduit(application).start(env, addon_name, access)
-    except NoClusterError:
-        # TODO: Set exception message in the exceptions and just output the message in the command code, should be able to catch all errors in one block
-        click.secho(f"""No ECS cluster found for "{app}" in "{env}" environment.""", fg="red")
-        exit(1)
-    except SecretNotFoundError as err:
-        click.secho(
-            f"""No secret called "{err}" for "{app}" in "{env}" environment.""",
-            fg="red",
+        secrets_provider: Secrets = Secrets(
+            application.environments[env].session.client("ssm"),
+            application.environments[env].session.client("secretsmanager"),
+            application.name,
+            env,
         )
-        exit(1)
-    except CreateTaskTimeoutError:
-        click.secho(
-            f"""Client ({addon_name}) ECS task has failed to start for "{app}" in "{env}" environment.""",
-            fg="red",
+        cloudformation_provider: CloudFormation = CloudFormation(
+            application.environments[env].session.client("cloudformation"),
+            application.environments[env].session.client("iam"),
+            application.environments[env].session.client("ssm"),
         )
-        exit(1)
-    except ParameterNotFoundError:
-        click.secho(
-            f"""No parameter called "/copilot/applications/{app}/environments/{env}/addons". Try deploying the "{app}" "{env}" environment.""",
-            fg="red",
-        )
-        exit(1)
-    except AddonNotFoundError:
-        click.secho(
-            f"""Addon "{addon_name}" does not exist.""",
-            fg="red",
-        )
-        exit(1)
-    except InvalidAddonTypeError as err:
-        click.secho(
-            f"""Addon type "{err.addon_type}" is not supported, we support: {", ".join(CONDUIT_ADDON_TYPES)}.""",
-            fg="red",
+
+        ecs_provider: ECS = ECS(
+            application.environments[env].session.client("ecs"),
+            application.environments[env].session.client("ssm"),
+            application.name,
+            env,
         )
-        exit(1)
-    except AddonTypeMissingFromConfigError:
-        click.secho(
-            f"""The configuration for the addon {addon_name}, is missconfigured and missing the addon type.""",
-            fg="red",
+
+        Conduit(application, secrets_provider, cloudformation_provider, ecs_provider).start(
+            env, addon_name, access
         )
-        exit(1)
+    except AWSException as err:
+        click.secho(str(err), fg="red")
+        raise click.Abort

dbt_platform_helper/commands/secrets.py

@@ -102,7 +102,6 @@ def list(app, env):
     params = dict(Path=path, Recursive=False, WithDecryption=True, MaxResults=10)
     secrets = []
 
-    # TODO: refactor shared code with get_ssm_secret_names - Check if this is still valid
     while True:
         response = client.get_parameters_by_path(**params)
 
@@ -114,6 +113,7 @@ def list(app, env):
         else:
             break
 
+    # 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)))
 
 

dbt_platform_helper/domain/codebase.py

@@ -11,7 +11,6 @@ from boto3 import Session
 
 from dbt_platform_helper.exceptions import ApplicationDeploymentNotTriggered
 from dbt_platform_helper.exceptions import ApplicationEnvironmentNotFoundError
-from dbt_platform_helper.exceptions import NoCopilotCodebasesFoundError
 from dbt_platform_helper.exceptions import NotInCodeBaseRepositoryError
 from dbt_platform_helper.utils.application import Application
 from dbt_platform_helper.utils.application import load_application
@@ -29,31 +28,31 @@ from dbt_platform_helper.utils.template import setup_templates
 class Codebase:
     def __init__(
         self,
-        input_fn: Callable[[str], str] = click.prompt,
-        echo_fn: Callable[[str], str] = click.secho,
-        confirm_fn: Callable[[str], bool] = click.confirm,
-        load_application_fn: Callable[[str], Application] = load_application,
-        get_aws_session_or_abort_fn: Callable[[str], Session] = get_aws_session_or_abort,
-        check_codebase_exists_fn: Callable[[str], str] = check_codebase_exists,
-        check_image_exists_fn: Callable[[str], str] = check_image_exists,
-        get_build_url_from_arn_fn: Callable[[str], str] = get_build_url_from_arn,
-        list_latest_images_fn: Callable[[str], str] = list_latest_images,
-        start_build_extraction_fn: Callable[[str], str] = start_build_extraction,
-        check_if_commit_exists_fn: Callable[[str], str] = check_if_commit_exists,
-        subprocess: Callable[[str], str] = subprocess.run,
+        input: Callable[[str], str] = click.prompt,
+        echo: Callable[[str], str] = click.secho,
+        confirm: Callable[[str], bool] = click.confirm,
+        load_application: Callable[[str], Application] = load_application,
+        get_aws_session_or_abort: Callable[[str], Session] = get_aws_session_or_abort,
+        check_codebase_exists: Callable[[str], str] = check_codebase_exists,
+        check_image_exists: Callable[[str], str] = check_image_exists,
+        get_build_url_from_arn: Callable[[str], str] = get_build_url_from_arn,
+        list_latest_images: Callable[[str], str] = list_latest_images,
+        start_build_extraction: Callable[[str], str] = start_build_extraction,
+        check_if_commit_exists: Callable[[str], str] = check_if_commit_exists,
+        run_subprocess: Callable[[str], str] = subprocess.run,
     ):
-        self.input_fn = input_fn
-        self.echo_fn = echo_fn
-        self.confirm_fn = confirm_fn
-        self.load_application_fn = load_application_fn
-        self.get_aws_session_or_abort_fn = get_aws_session_or_abort_fn
-        self.check_codebase_exists_fn = check_codebase_exists_fn
-        self.check_image_exists_fn = check_image_exists_fn
-        self.get_build_url_from_arn_fn = get_build_url_from_arn_fn
-        self.list_latest_images_fn = list_latest_images_fn
-        self.start_build_extraction_fn = start_build_extraction_fn
-        self.check_if_commit_exists_fn = check_if_commit_exists_fn
-        self.subprocess = subprocess
+        self.input = input
+        self.echo = echo
+        self.confirm = confirm
+        self.load_application = load_application
+        self.get_aws_session_or_abort = get_aws_session_or_abort
+        self.check_codebase_exists = check_codebase_exists
+        self.check_image_exists = check_image_exists
+        self.get_build_url_from_arn = get_build_url_from_arn
+        self.list_latest_images = list_latest_images
+        self.start_build_extraction = start_build_extraction
+        self.check_if_commit_exists = check_if_commit_exists
+        self.run_subprocess = run_subprocess
 
     def prepare(self):
         """Sets up an application codebase for use within a DBT platform
@@ -61,13 +60,15 @@ class Codebase:
         templates = setup_templates()
 
         repository = (
-            self.subprocess(["git", "remote", "get-url", "origin"], capture_output=True, text=True)
+            self.run_subprocess(
+                ["git", "remote", "get-url", "origin"], capture_output=True, text=True
+            )
             .stdout.split("/")[-1]
             .strip()
             .removesuffix(".git")
         )
         if repository.endswith("-deploy") or Path("./copilot").exists():
-            raise NotInCodeBaseRepositoryError
+            raise NotInCodeBaseRepositoryError()
 
         builder_configuration_url = "https://raw.githubusercontent.com/uktrade/ci-image-builder/main/image_builder/configuration/builder_configuration.yml"
         builder_configuration_response = requests.get(builder_configuration_url)
@@ -91,7 +92,7 @@ class Codebase:
         config_contents = templates.get_template(f".copilot/config.yml").render(
             repository=repository, builder_version=builder_version
         )
-        self.echo_fn(
+        self.echo(
             mkfile(
                 Path("."), ".copilot/image_build_run.sh", image_build_run_contents, overwrite=True
             )
@@ -100,27 +101,27 @@ class Codebase:
         image_build_run_file = Path(".copilot/image_build_run.sh")
         image_build_run_file.chmod(image_build_run_file.stat().st_mode | stat.S_IEXEC)
 
-        self.echo_fn(mkfile(Path("."), ".copilot/config.yml", config_contents, overwrite=True))
+        self.echo(mkfile(Path("."), ".copilot/config.yml", config_contents, overwrite=True))
 
         for phase in ["build", "install", "post_build", "pre_build"]:
             phase_contents = templates.get_template(f".copilot/phases/{phase}.sh").render()
 
-            self.echo_fn(
+            self.echo(
                 mkfile(Path("./.copilot"), f"phases/{phase}.sh", phase_contents, overwrite=True)
             )
 
     def build(self, app: str, codebase: str, commit: str):
         """Trigger a CodePipeline pipeline based build."""
-        session = self.get_aws_session_or_abort_fn()
-        self.load_application_fn(app, default_session=session)
+        session = self.get_aws_session_or_abort()
+        self.load_application(app, default_session=session)
 
-        self.check_if_commit_exists_fn(commit)
+        self.check_if_commit_exists(commit)
 
         codebuild_client = session.client("codebuild")
         build_url = self.__start_build_with_confirmation(
-            self.confirm_fn,
+            self.confirm,
             codebuild_client,
-            self.get_build_url_from_arn_fn,
+            self.get_build_url_from_arn,
             f'You are about to build "{app}" for "{codebase}" with commit "{commit}". Do you want to continue?',
             {
                 "projectName": f"codebuild-{app}-{codebase}",
@@ -130,29 +131,29 @@ class Codebase:
         )
 
         if build_url:
-            return self.echo_fn(
+            return self.echo(
                 f"Your build has been triggered. Check your build progress in the AWS Console: {build_url}"
             )
 
-        raise ApplicationDeploymentNotTriggered()
+        raise ApplicationDeploymentNotTriggered(codebase)
 
     def deploy(self, app, env, codebase, commit):
         """Trigger a CodePipeline pipeline based deployment."""
-        session = self.get_aws_session_or_abort_fn()
+        session = self.get_aws_session_or_abort()
 
-        application = self.load_application_fn(app, default_session=session)
+        application = self.load_application(app, default_session=session)
         if not application.environments.get(env):
-            raise ApplicationEnvironmentNotFoundError()
+            raise ApplicationEnvironmentNotFoundError(env)
 
-        self.check_codebase_exists_fn(session, application, codebase)
+        self.check_codebase_exists(session, application, codebase)
 
-        self.check_image_exists_fn(session, application, codebase, commit)
+        self.check_image_exists(session, application, codebase, commit)
 
         codebuild_client = session.client("codebuild")
         build_url = self.__start_build_with_confirmation(
-            self.confirm_fn,
+            self.confirm,
             codebuild_client,
-            self.get_build_url_from_arn_fn,
+            self.get_build_url_from_arn,
             f'You are about to deploy "{app}" for "{codebase}" with commit "{commit}" to the "{env}" environment. Do you want to continue?',
             {
                 "projectName": f"pipeline-{application.name}-{codebase}-BuildProject",
@@ -166,34 +167,34 @@ class Codebase:
         )
 
         if build_url:
-            return self.echo_fn(
+            return self.echo(
                 "Your deployment has been triggered. Check your build progress in the AWS Console: "
                 f"{build_url}",
             )
 
-        raise ApplicationDeploymentNotTriggered()
+        raise ApplicationDeploymentNotTriggered(codebase)
 
     def list(self, app: str, with_images: bool):
         """List available codebases for the application."""
-        session = self.get_aws_session_or_abort_fn()
-        application = self.load_application_fn(app, session)
+        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)
 
-        self.echo_fn("The following codebases are available:")
+        self.echo("The following codebases are available:")
 
         for codebase in codebases:
-            self.echo_fn(f"- {codebase['name']} (https://github.com/{codebase['repository']})")
+            self.echo(f"- {codebase['name']} (https://github.com/{codebase['repository']})")
             if with_images:
-                self.list_latest_images_fn(
+                self.list_latest_images(
                     ecr_client,
                     f"{application.name}/{codebase['name']}",
                     codebase["repository"],
-                    self.echo_fn,
+                    self.echo,
                 )
 
-        self.echo_fn("")
+        self.echo("")
 
     def __get_codebases(self, application, ssm_client):
         parameters = ssm_client.get_parameters_by_path(
@@ -204,19 +205,18 @@ class Codebase:
         codebases = [json.loads(p["Value"]) for p in parameters]
 
         if not codebases:
-            # TODO Is this really an error? Or just no codebases so we could return an empty list?
-            raise NoCopilotCodebasesFoundError
+            return []
         return codebases
 
     def __start_build_with_confirmation(
         self,
-        confirm_fn,
+        confirm,
         codebuild_client,
-        get_build_url_from_arn_fn,
+        get_build_url_from_arn,
         confirmation_message,
         build_options,
     ):
-        if confirm_fn(confirmation_message):
-            build_arn = self.start_build_extraction_fn(codebuild_client, build_options)
-            return get_build_url_from_arn_fn(build_arn)
+        if confirm(confirmation_message):
+            build_arn = self.start_build_extraction(codebuild_client, build_options)
+            return get_build_url_from_arn(build_arn)
         return None

dbt_platform_helper/domain/conduit.py

@@ -3,80 +3,54 @@ from collections.abc import Callable
 
 import click
 
-from dbt_platform_helper.exceptions import ECSAgentNotRunning
-from dbt_platform_helper.providers.cloudformation import (
-    add_stack_delete_policy_to_task_role,
-)
-from dbt_platform_helper.providers.cloudformation import update_conduit_stack_resources
-from dbt_platform_helper.providers.cloudformation import (
-    wait_for_cloudformation_to_reach_status,
-)
+from dbt_platform_helper.providers.cloudformation import CloudFormation
 from dbt_platform_helper.providers.copilot import connect_to_addon_client_task
 from dbt_platform_helper.providers.copilot import create_addon_client_task
 from dbt_platform_helper.providers.copilot import create_postgres_admin_task
-from dbt_platform_helper.providers.ecs import ecs_exec_is_available
-from dbt_platform_helper.providers.ecs import get_cluster_arn
-from dbt_platform_helper.providers.ecs import get_ecs_task_arns
-from dbt_platform_helper.providers.ecs import get_or_create_task_name
-from dbt_platform_helper.providers.secrets import get_addon_type
-from dbt_platform_helper.providers.secrets import get_parameter_name
+from dbt_platform_helper.providers.ecs import ECS
+from dbt_platform_helper.providers.secrets import Secrets
 from dbt_platform_helper.utils.application import Application
-from dbt_platform_helper.utils.messages import abort_with_error
 
 
 class Conduit:
     def __init__(
         self,
         application: Application,
-        echo_fn: Callable[[str], str] = click.secho,
-        subprocess_fn: subprocess = subprocess,
-        get_ecs_task_arns_fn=get_ecs_task_arns,
-        connect_to_addon_client_task_fn=connect_to_addon_client_task,
-        create_addon_client_task_fn=create_addon_client_task,
-        create_postgres_admin_task_fn=create_postgres_admin_task,
-        get_addon_type_fn=get_addon_type,
-        ecs_exec_is_available_fn=ecs_exec_is_available,
-        get_cluster_arn_fn=get_cluster_arn,
-        get_parameter_name_fn=get_parameter_name,
-        get_or_create_task_name_fn=get_or_create_task_name,
-        add_stack_delete_policy_to_task_role_fn=add_stack_delete_policy_to_task_role,
-        update_conduit_stack_resources_fn=update_conduit_stack_resources,
-        wait_for_cloudformation_to_reach_status_fn=wait_for_cloudformation_to_reach_status,
-        abort_fn=abort_with_error,
+        secrets_provider: Secrets,
+        cloudformation_provider: CloudFormation,
+        ecs_provider: ECS,
+        echo: Callable[[str], str] = click.secho,
+        subprocess: subprocess = subprocess,
+        connect_to_addon_client_task=connect_to_addon_client_task,
+        create_addon_client_task=create_addon_client_task,
+        create_postgres_admin_task=create_postgres_admin_task,
     ):
 
         self.application = application
-        self.subprocess_fn = subprocess_fn
-        self.echo_fn = echo_fn
-        self.get_ecs_task_arns_fn = get_ecs_task_arns_fn
-        self.connect_to_addon_client_task_fn = connect_to_addon_client_task_fn
-        self.create_addon_client_task_fn = create_addon_client_task_fn
-        self.create_postgres_admin_task = create_postgres_admin_task_fn
-        self.get_addon_type_fn = get_addon_type_fn
-        self.ecs_exec_is_available_fn = ecs_exec_is_available_fn
-        self.get_cluster_arn_fn = get_cluster_arn_fn
-        self.get_parameter_name_fn = get_parameter_name_fn
-        self.get_or_create_task_name_fn = get_or_create_task_name_fn
-        self.add_stack_delete_policy_to_task_role_fn = add_stack_delete_policy_to_task_role_fn
-        self.update_conduit_stack_resources_fn = update_conduit_stack_resources_fn
-        self.wait_for_cloudformation_to_reach_status_fn = wait_for_cloudformation_to_reach_status_fn
-        self.abort_fn = abort_fn
+        self.secrets_provider = secrets_provider
+        self.cloudformation_provider = cloudformation_provider
+        self.ecs_provider = ecs_provider
+        self.subprocess = subprocess
+        self.echo = echo
+        self.connect_to_addon_client_task = connect_to_addon_client_task
+        self.create_addon_client_task = create_addon_client_task
+        self.create_postgres_admin_task = create_postgres_admin_task
 
     def start(self, env: str, addon_name: str, access: str = "read"):
         clients = self._initialise_clients(env)
         addon_type, cluster_arn, parameter_name, task_name = self._get_addon_details(
-            env, addon_name, access
+            addon_name, access
         )
 
-        self.echo_fn(f"Checking if a conduit task is already running for {addon_type}")
-        task_arn = self.get_ecs_task_arns_fn(clients["ecs"], cluster_arn, task_name)
-        if not task_arn:
-            self.echo_fn("Creating conduit task")
-            self.create_addon_client_task_fn(
+        self.echo(f"Checking if a conduit task is already running for {addon_type}")
+        task_arns = self.ecs_provider.get_ecs_task_arns(cluster_arn, task_name)
+        if not task_arns:
+            self.echo("Creating conduit task")
+            self.create_addon_client_task(
                 clients["iam"],
                 clients["ssm"],
                 clients["secrets_manager"],
-                self.subprocess_fn,
+                self.subprocess,
                 self.application,
                 env,
                 addon_type,
@@ -85,11 +59,8 @@ class Conduit:
                 access,
             )
 
-            self.echo_fn("Updating conduit task")
+            self.echo("Updating conduit task")
             self._update_stack_resources(
-                clients["cloudformation"],
-                clients["iam"],
-                clients["ssm"],
                 self.application.name,
                 env,
                 addon_type,
@@ -99,21 +70,18 @@ class Conduit:
                 access,
             )
 
-            task_arn = self.get_ecs_task_arns_fn(clients["ecs"], cluster_arn, task_name)
+            task_arns = self.ecs_provider.get_ecs_task_arns(cluster_arn, task_name)
 
         else:
-            self.echo_fn("Conduit task already running")
+            self.echo("Conduit task already running")
 
-        self.echo_fn(f"Checking if exec is available for conduit task...")
+        self.echo(f"Checking if exec is available for conduit task...")
 
-        try:
-            self.ecs_exec_is_available_fn(clients["ecs"], cluster_arn, task_arn)
-        except ECSAgentNotRunning:
-            self.abort_fn('ECS exec agent never reached "RUNNING" status')
+        self.ecs_provider.ecs_exec_is_available(cluster_arn, task_arns)
 
-        self.echo_fn("Connecting to conduit task")
-        self.connect_to_addon_client_task_fn(
-            clients["ecs"], self.subprocess_fn, self.application.name, env, cluster_arn, task_name
+        self.echo("Connecting to conduit task")
+        self.connect_to_addon_client_task(
+            clients["ecs"], self.subprocess, self.application.name, env, cluster_arn, task_name
         )
 
     def _initialise_clients(self, env):
@@ -125,26 +93,16 @@ class Conduit:
             "secrets_manager": self.application.environments[env].session.client("secretsmanager"),
         }
 
-    def _get_addon_details(self, env, addon_name, access):
-        ssm_client = self.application.environments[env].session.client("ssm")
-        ecs_client = self.application.environments[env].session.client("ecs")
-
-        addon_type = self.get_addon_type_fn(ssm_client, self.application.name, env, addon_name)
-        cluster_arn = self.get_cluster_arn_fn(ecs_client, self.application.name, env)
-        parameter_name = self.get_parameter_name_fn(
-            self.application.name, env, addon_type, addon_name, access
-        )
-        task_name = self.get_or_create_task_name_fn(
-            ssm_client, self.application.name, env, addon_name, parameter_name
-        )
+    def _get_addon_details(self, addon_name, access):
+        addon_type = self.secrets_provider.get_addon_type(addon_name)
+        cluster_arn = self.ecs_provider.get_cluster_arn()
+        parameter_name = self.secrets_provider.get_parameter_name(addon_type, addon_name, access)
+        task_name = self.ecs_provider.get_or_create_task_name(addon_name, parameter_name)
 
         return addon_type, cluster_arn, parameter_name, task_name
 
     def _update_stack_resources(
         self,
-        cloudformation_client,
-        iam_client,
-        ssm_client,
         app_name,
         env,
         addon_type,
@@ -153,11 +111,8 @@ class Conduit:
         parameter_name,
         access,
     ):
-        self.add_stack_delete_policy_to_task_role_fn(cloudformation_client, iam_client, task_name)
-        stack_name = self.update_conduit_stack_resources_fn(
-            cloudformation_client,
-            iam_client,
-            ssm_client,
+        self.cloudformation_provider.add_stack_delete_policy_to_task_role(task_name)
+        stack_name = self.cloudformation_provider.update_conduit_stack_resources(
             app_name,
             env,
             addon_type,
@@ -166,7 +121,7 @@ class Conduit:
             parameter_name,
             access,
         )
-        self.echo_fn("Waiting for conduit task update to complete...")
-        self.wait_for_cloudformation_to_reach_status_fn(
-            cloudformation_client, "stack_update_complete", stack_name
+        self.echo("Waiting for conduit task update to complete...")
+        self.cloudformation_provider.wait_for_cloudformation_to_reach_status(
+            "stack_update_complete", stack_name
         )