aws-annoying 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

aws_annoying/cli/ecs/wait_for_deployment.py

@@ -6,7 +6,15 @@ from typing import Optional
 
 import typer
 
-from aws_annoying.ecs import DeploymentFailedError, ECSDeploymentWaiter, ECSServiceRef
+from aws_annoying.ecs import (
+    DeploymentFailedError,
+    ECSServiceRef,
+    ServiceTaskDefinitionAssertionError,
+    check_service_task_definition,
+    wait_for_deployment_complete,
+    wait_for_deployment_start,
+    wait_for_service_stability,
+)
 from aws_annoying.utils.timeout import OperationTimeoutError, Timeout
 
 from ._app import ecs_app
@@ -63,10 +71,10 @@ def wait_for_deployment(  # noqa: PLR0913
 ) -> None:
     """Wait for ECS deployment to complete."""
     start = datetime.now(tz=timezone.utc)
-    waiter = ECSDeploymentWaiter(ECSServiceRef(cluster=cluster, service=service))
     try:
         with Timeout(timeout_seconds):
-            waiter.wait(
+            _wait_for_deployment(
+                ECSServiceRef(cluster=cluster, service=service),
                 wait_for_start=wait_for_start,
                 polling_interval=polling_interval,
                 wait_for_stability=wait_for_stability,
@@ -92,3 +100,59 @@ def wait_for_deployment(  # noqa: PLR0913
             "Deployment completed in [bold]%.2f[/bold] seconds.",
             elapsed.total_seconds(),
         )
+
+
+def _wait_for_deployment(
+    service_ref: ECSServiceRef,
+    *,
+    wait_for_start: bool,
+    polling_interval: int = 5,
+    wait_for_stability: bool,
+    expected_task_definition: str | None = None,
+) -> None:
+    # Find current deployment for the service
+    logger.info(
+        "Looking up running deployment for service %s",
+        service_ref.service,
+    )
+    latest_deployment_arn = wait_for_deployment_start(
+        service_ref,
+        wait_for_start=wait_for_start,
+        polling_interval=polling_interval,
+    )
+
+    # Polling for the deployment to finish (successfully or unsuccessfully)
+    logger.info(
+        "Start waiting for deployment %s to finish.",
+        latest_deployment_arn,
+    )
+    ok, status = wait_for_deployment_complete(latest_deployment_arn, polling_interval=polling_interval)
+    if ok:
+        logger.info(
+            "Deployment succeeded with status %s",
+            status,
+        )
+    else:
+        msg = f"Deployment failed with status: {status}"
+        raise DeploymentFailedError(msg)
+
+    # Wait for the service to be stable
+    if wait_for_stability:
+        logger.info(
+            "Start waiting for service %s to be stable.",
+            service_ref.service,
+        )
+        wait_for_service_stability(service_ref, polling_interval=polling_interval)
+
+    # Check if the service task definition matches the expected one
+    if expected_task_definition:
+        logger.info(
+            "Checking if the service task definition is the expected one: %s",
+            expected_task_definition,
+        )
+        ok, actual = check_service_task_definition(service_ref, expect=expected_task_definition)
+        if not ok:
+            msg = f"The service task definition is not the expected one; got: {actual!r}"
+            raise ServiceTaskDefinitionAssertionError(msg)
+
+        logger.info("The service task definition matches the expected one.")

aws_annoying/cli/load_variables.py

@@ -78,8 +78,6 @@ def load_variables(
     The variables are loaded in the order of option provided, overwriting the variables with the same name in the order of the ARNs.
     Existing environment variables are preserved by default, unless `--overwrite-env` is provided.
     """  # noqa: E501
-    dry_run = ctx.meta["dry_run"]
-
     command = ctx.args
     if not command:
         logger.warning("No command provided. Exiting...")
@@ -109,9 +107,6 @@ def load_variables(
     # Retrieve the variables
     loader = VariableLoader()
     logger.info("Retrieving variables from AWS resources...")
-    if dry_run:
-        logger.warning("Dry run mode enabled. Variables won't be loaded from AWS.")
-
     try:
         variables, load_stats = loader.load(map_arns_by_index)
     except Exception as exc:  # noqa: BLE001

aws_annoying/ecs/__init__.py

@@ -1,17 +1,25 @@
+from .check import check_service_task_definition
 from .common import ECSServiceRef
-from .deployment_waiter import ECSDeploymentWaiter
 from .errors import (
     DeploymentFailedError,
     NoRunningDeploymentError,
     ServiceTaskDefinitionAssertionError,
     WaitForDeploymentError,
 )
+from .wait_for import (
+    wait_for_deployment_complete,
+    wait_for_deployment_start,
+    wait_for_service_stability,
+)
 
 __all__ = (
     "DeploymentFailedError",
-    "ECSDeploymentWaiter",
     "ECSServiceRef",
     "NoRunningDeploymentError",
     "ServiceTaskDefinitionAssertionError",
     "WaitForDeploymentError",
+    "check_service_task_definition",
+    "wait_for_deployment_complete",
+    "wait_for_deployment_start",
+    "wait_for_service_stability",
 )

aws_annoying/ecs/check.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+import boto3
+
+if TYPE_CHECKING:
+    from .common import ECSServiceRef
+
+logger = logging.getLogger(__name__)
+
+
+def check_service_task_definition(
+    service_ref: ECSServiceRef,
+    *,
+    session: boto3.session.Session | None = None,
+    expect: str,
+) -> tuple[bool, str]:
+    """Check the service's current task definition matches the expected one.
+
+    Args:
+        service_ref: The ECS service reference containing the cluster and service names.
+        session: The boto3 session to use for the ECS client.
+        expect: The ARN of expected task definition.
+
+    Returns:
+        A tuple containing a boolean indicating whether the task definition matches the expected one
+        and the current task definition ARN.
+    """
+    session = session or boto3.session.Session()
+    ecs = session.client("ecs")
+
+    service_detail = ecs.describe_services(cluster=service_ref.cluster, services=[service_ref.service])["services"][0]
+    current_task_definition_arn = service_detail["taskDefinition"]
+    if current_task_definition_arn != expect:
+        return (False, current_task_definition_arn)
+
+    return (True, current_task_definition_arn)

aws_annoying/ecs/wait_for.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from time import sleep
+from typing import TYPE_CHECKING
+
+import boto3
+import botocore.exceptions
+
+from .errors import NoRunningDeploymentError
+
+if TYPE_CHECKING:
+    from .common import ECSServiceRef
+
+logger = logging.getLogger(__name__)
+
+
+def wait_for_deployment_start(
+    service_ref: ECSServiceRef,
+    *,
+    session: boto3.session.Session | None = None,
+    wait_for_start: bool,
+    polling_interval: int = 5,
+    max_attempts: int | None = None,
+) -> str:
+    """Wait for the ECS deployment to start.
+
+    Args:
+        service_ref: The ECS service reference containing the cluster and service names.
+        session: The boto3 session to use for the ECS client.
+        wait_for_start: Whether to wait for the deployment to start.
+        polling_interval: The interval between any polling attempts, in seconds.
+        max_attempts: The maximum number of attempts to wait for the deployment to start.
+
+    Raises:
+        NoRunningDeploymentError: If no running deployments are found and `wait_for_start` is False.
+
+    Returns:
+        The ARN of the latest deployment for the service.
+    """
+    session = session or boto3.session.Session()
+    ecs = session.client("ecs")
+
+    if wait_for_start:
+        logger.warning("`wait_for_start` is set, will wait for a new deployment to start.")
+
+    attempts = 0
+    while True:  # do-while
+        # Do
+        running_deployments = ecs.list_service_deployments(
+            cluster=service_ref.cluster,
+            service=service_ref.service,
+            status=["PENDING", "IN_PROGRESS"],
+        )["serviceDeployments"]
+
+        # While
+        if running_deployments:
+            logger.debug("Found %d running deployments for service. Exiting loop.", len(running_deployments))
+            break
+
+        if not wait_for_start:
+            logger.debug("`wait_for_start` is off, no need to wait for a new deployment to start.")
+            break
+
+        if max_attempts and attempts >= max_attempts:
+            logger.debug("Max attempts exceeded while waiting for a new deployment to start.")
+            break
+
+        logger.debug(
+            "(%d-th attempt) No running deployments found for service. Start waiting for a new deployment.",
+            attempts + 1,
+        )
+
+        sleep(polling_interval)
+        attempts += 1
+
+    if not running_deployments:
+        msg = "No running deployments found for service."
+        raise NoRunningDeploymentError(msg)
+
+    latest_deployment = max(
+        running_deployments,
+        key=lambda dep: dep.get(
+            "startedAt",
+            datetime.min.replace(tzinfo=timezone.utc),
+        ),
+    )
+    if len(running_deployments) > 1:
+        logger.warning(
+            "%d running deployments found for service. Using most recently started deployment: %s",
+            len(running_deployments),
+            latest_deployment["serviceDeploymentArn"],
+        )
+
+    return latest_deployment["serviceDeploymentArn"]
+
+
+def wait_for_deployment_complete(
+    deployment_arn: str,
+    *,
+    session: boto3.session.Session | None = None,
+    polling_interval: int = 5,
+    max_attempts: int | None = None,
+) -> tuple[bool, str]:
+    """Wait for the ECS deployment to complete.
+
+    Args:
+        deployment_arn: The ARN of the deployment to wait for.
+        session: The boto3 session to use for the ECS client.
+        polling_interval: The interval between any polling attempts, in seconds.
+        max_attempts: The maximum number of attempts to wait for the deployment to complete.
+
+    Returns:
+        A tuple containing a boolean indicating whether the deployment succeeded and the status of the deployment.
+    """
+    session = session or boto3.session.Session()
+    ecs = session.client("ecs")
+
+    attempts = 0
+    while (max_attempts is None) or (attempts <= max_attempts):
+        latest_deployment = ecs.describe_service_deployments(serviceDeploymentArns=[deployment_arn])[
+            "serviceDeployments"
+        ][0]
+        status = latest_deployment["status"]
+        if status == "SUCCESSFUL":
+            return (True, status)
+
+        if status in ("PENDING", "IN_PROGRESS"):
+            logger.debug(
+                "(%d-th attempt) Deployment in progress... (%s)",
+                attempts + 1,
+                status,
+            )
+        else:
+            break
+
+        sleep(polling_interval)
+        attempts += 1
+
+    return (False, status)
+
+
+def wait_for_service_stability(
+    service_ref: ECSServiceRef,
+    *,
+    session: boto3.session.Session | None = None,
+    polling_interval: int = 5,
+    max_attempts: int | None = None,
+) -> bool:
+    """Wait for the ECS service to be stable.
+
+    Args:
+        service_ref: The ECS service reference containing the cluster and service names.
+        session: The boto3 session to use for the ECS client.
+        polling_interval: The interval between any polling attempts, in seconds.
+        max_attempts: The maximum number of attempts to wait for the service to be stable.
+
+    Returns:
+        A boolean indicating whether the service is stable.
+    """
+    session = session or boto3.session.Session()
+    ecs = session.client("ecs")
+
+    # TODO(lasuillard): Likely to be a problem in some cases: https://github.com/boto/botocore/issues/3314
+    stability_waiter = ecs.get_waiter("services_stable")
+
+    attempts = 0
+    while (max_attempts is None) or (attempts <= max_attempts):
+        logger.debug(
+            "(%d-th attempt) Waiting for service %s to be stable...",
+            attempts + 1,
+            service_ref.service,
+        )
+        try:
+            stability_waiter.wait(
+                cluster=service_ref.cluster,
+                services=[service_ref.service],
+                WaiterConfig={"Delay": polling_interval, "MaxAttempts": 1},
+            )
+        except botocore.exceptions.WaiterError as err:
+            if err.kwargs["reason"] != "Max attempts exceeded":
+                raise
+        else:
+            return True
+
+        sleep(polling_interval)
+        attempts += 1
+
+    return False

aws_annoying/utils/downloader.py

@@ -42,14 +42,7 @@ class TQDMDownloader(AbstractDownloader):
             total_size = int(response.headers.get("content-length", 0))
             with (
                 to.open("wb") as f,
-                tqdm(
-                    # Make the URL less verbose in the progress bar
-                    desc=url.replace("https://s3.amazonaws.com/session-manager-downloads/plugin", "..."),
-                    total=total_size,
-                    unit="iB",
-                    unit_scale=True,
-                    unit_divisor=1_024,
-                ) as pbar,
+                tqdm(desc=url, total=total_size, unit="iB", unit_scale=True, unit_divisor=1_024) as pbar,
             ):
                 for chunk in response.iter_content(chunk_size=8_192):
                     size = f.write(chunk)

aws_annoying/utils/ec2.py

@@ -26,11 +26,8 @@ def get_instance_id_by_name(name_or_id: str, *, session: boto3.session.Session |
 
     response = ec2.describe_instances(Filters=[{"Name": "tag:Name", "Values": [name_or_id]}])
     reservations = response["Reservations"]
-    if not reservations:
+    if not reservations or not reservations[0]["Instances"]:
         return None
 
     instances = reservations[0]["Instances"]
-    if not instances:
-        return None
-
     return str(instances[0]["InstanceId"])

aws_annoying/utils/timeout.py

@@ -2,9 +2,7 @@ from __future__ import annotations
 
 import signal
 from functools import wraps
-from typing import TYPE_CHECKING, Callable, Optional, TypeVar, cast
-
-from pydantic import PositiveInt, validate_call
+from typing import TYPE_CHECKING, Callable, TypeVar, cast
 
 from aws_annoying.utils.platform import is_windows
 
@@ -27,8 +25,7 @@ class Timeout:
     to do nothing on Windows OS.
     """
 
-    @validate_call
-    def __init__(self, seconds: Optional[PositiveInt]) -> None:
+    def __init__(self, seconds: int | None) -> None:
         """Initialize timeout handler.
 
         Args:

{aws_annoying-0.6.0.dist-info → aws_annoying-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-annoying
-Version: 0.6.0
+Version: 0.7.0
 Summary: Utils to handle some annoying AWS tasks.
 Project-URL: Homepage, https://github.com/lasuillard/aws-annoying
 Project-URL: Repository, https://github.com/lasuillard/aws-annoying.git
@@ -16,7 +16,7 @@ Requires-Dist: tqdm<5,>=4
 Requires-Dist: typer<1,>=0
 Provides-Extra: dev
 Requires-Dist: boto3-stubs[ec2,ecs,secretsmanager,ssm,sts]>=1.37.1; extra == 'dev'
-Requires-Dist: mypy~=1.15.0; extra == 'dev'
+Requires-Dist: mypy<1.17,>=1.15; extra == 'dev'
 Requires-Dist: ruff<0.12.0,>=0.9.9; extra == 'dev'
 Requires-Dist: types-requests>=2.31.0.6; extra == 'dev'
 Provides-Extra: test

{aws_annoying-0.6.0.dist-info → aws_annoying-0.7.0.dist-info}/RECORD

@@ -3,13 +3,13 @@ aws_annoying/mfa_config.py,sha256=z0GpRhLHEWaaXbECV4Ei4oNM1WCFoEZAxCIPbpY4Ymc,22
 aws_annoying/variable_loader.py,sha256=N9qPPHG6mzSIIHrWJnJ_FV5kKZxssOaTHoAQEwiDE3s,4569
 aws_annoying/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aws_annoying/cli/app.py,sha256=6opsAfIFGPnUSK68s7sEnFzLhipnevfP2cDJ0yj7Lh0,2366
-aws_annoying/cli/load_variables.py,sha256=83RGt5eA_TJtza3kyLXoSM_A3lfQs6TNC2TCrWYia_I,5032
+aws_annoying/cli/load_variables.py,sha256=n5CIci_uAoGaOZ4EKIKEEfcyMq81Hjy9AFOXq1-Hbh0,4896
 aws_annoying/cli/logging_handler.py,sha256=JPsZePV3YH9e1nLv0Q3fqSeXSEfZ5cGJo6eLK2F4oxE,1426
 aws_annoying/cli/main.py,sha256=bU4Gxic5_3qrrd8l9eN709-D4o_OHgrdH91FS9Xs8zI,477
 aws_annoying/cli/ecs/__init__.py,sha256=IxfaMXcGU6WTHE_RXj-aitXtSg25j5m3HGTG9O02GjI,125
 aws_annoying/cli/ecs/_app.py,sha256=izD0VL55i7oG-2CtWCV21bSoAeE-DZbxyJ5pi6VXhjU,200
 aws_annoying/cli/ecs/task_definition_lifecycle.py,sha256=W7zr8zEPjjHgss9Tnb3QMcJ_45Yb9SJ5D1B315vb9kc,2803
-aws_annoying/cli/ecs/wait_for_deployment.py,sha256=0lzl5t0TOvJJeMxIA6if2TbG7bJFf6JulhPHZqNXjFM,3169
+aws_annoying/cli/ecs/wait_for_deployment.py,sha256=yBl-KMOya8ZSgpZLcEB0UqtsZfK5ezKPJWNaOdMRRcY,5234
 aws_annoying/cli/mfa/__init__.py,sha256=rbEGhw5lOQZV_XAc3nSbo56JVhsSPpeOgEtiAy9qzEA,50
 aws_annoying/cli/mfa/_app.py,sha256=Ub7gxb6kGF3Ve1ucQSOjHmc4jAu8mxgegcXsIbOzLLQ,189
 aws_annoying/cli/mfa/configure.py,sha256=s2SCz7gzvIE9mJM7w95JPwoGhuQrgkFhjUd6qjD169k,3957
@@ -20,22 +20,23 @@ aws_annoying/cli/session_manager/install.py,sha256=VIk6313jUf6THwvs06AOUQwhTjzCG
 aws_annoying/cli/session_manager/port_forward.py,sha256=upsUsd7MkUfaAP3o0ZK6N-SkOBnr1ogwqYozG4TDTzY,4331
 aws_annoying/cli/session_manager/start.py,sha256=1Q-WFvbQkMgVntwIrM2HfpUKmVL38aFrjJjG3aA0fzU,1447
 aws_annoying/cli/session_manager/stop.py,sha256=QjjOmmhZr_0IInhOyHvSlodk7Nx4qu9EtrRw4kl8Hks,1535
-aws_annoying/ecs/__init__.py,sha256=Bohwe4-jxF1cxQmErCXl0l5ma08HpWmV2PqdAS-gf4w,432
+aws_annoying/ecs/__init__.py,sha256=G9vVNkbDg-fY3G0Qc7yOGZOnsVp4VtiwzzEgjr6S5Kw,666
+aws_annoying/ecs/check.py,sha256=mxkW8MWCJYng60VKwq3Ws9PEvI1u0aVPdbs4p6SY2j4,1233
 aws_annoying/ecs/common.py,sha256=TvP27SEvdIBnA92Oude-oDCy1SuaYNdtpokkbpZmdzo,139
-aws_annoying/ecs/deployment_waiter.py,sha256=e3xWShvr9piraoEMJdZun2GuffkyvTI76-riECfoe9A,9936
 aws_annoying/ecs/errors.py,sha256=n9j_h1MDUV6IVabKgwbCVAiPZQNJDJ5rVRHA82Je5QQ,429
+aws_annoying/ecs/wait_for.py,sha256=Oj1u1uPp074-Pf-cvVNHxs-S6RLk8lh5EGsVFqi1iH0,6123
 aws_annoying/session_manager/__init__.py,sha256=IENviL3ux2LF7o9xFGYEiqaGw03hxnyNX2btbB1xyEU,318
 aws_annoying/session_manager/errors.py,sha256=YioKlRtZ-GUP0F_ts_ebw7-HYkxe8mTes6HK821Kuiw,353
 aws_annoying/session_manager/session_manager.py,sha256=pUsyJ_w9UzdIfHA2Z8kU6UcZxOqypFXH1rl6pDytdqo,12046
 aws_annoying/session_manager/shortcuts.py,sha256=Yn4wCl43lfttrZ7GbzfGua2jZHe5Fe6ClEy4ikg-Q_s,2143
 aws_annoying/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aws_annoying/utils/debugger.py,sha256=UFllDCGI2gPtwo1XS5vqw0qyR6bYr7XknmBwSxalKIc,754
-aws_annoying/utils/downloader.py,sha256=aB5RzT-LpbFX24-2HXlAkdgVowc4TR9FWT_K8WwZ1BE,1923
-aws_annoying/utils/ec2.py,sha256=RjEA5eO53c-H6VE6cZBeB1RJo1rxpDQFhbZTYdANbs8,1062
+aws_annoying/utils/downloader.py,sha256=bAh8Hu55L3F8Fyd1s4NBsyB_L0U-lk7SfKsS00Rp5fA,1660
+aws_annoying/utils/ec2.py,sha256=VsOrnFQDSNplWQ_s-uT11IfiD2mi-74uLbSVoaeXynI,1055
 aws_annoying/utils/platform.py,sha256=TBIzCzYiFj36HmndZedegvFlxPSNtBQyAxzuwelvxNg,985
-aws_annoying/utils/timeout.py,sha256=PjfFtiLALh7lQvchtMYOfjTNrfuZwCaeaPKW16EpM5c,2483
-aws_annoying-0.6.0.dist-info/METADATA,sha256=68sKE-Atya0ibgT1ljJsaKHpnKXHDq-x7EdUy0yRIqI,3503
-aws_annoying-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aws_annoying-0.6.0.dist-info/entry_points.txt,sha256=DcKE5V0WvVJ8wUOHxyUz1yLAJOuuJUgRPlMcQ4O7jEs,66
-aws_annoying-0.6.0.dist-info/licenses/LICENSE,sha256=Q5GkvYijQ2KTQ-QWhv43ilzCno4ZrzrEuATEQZd9rYo,1067
-aws_annoying-0.6.0.dist-info/RECORD,,
+aws_annoying/utils/timeout.py,sha256=9eCSqhkEp7f7wBoLzkyqfyUKAgY9irwL6LIWBvIvmFI,2394
+aws_annoying-0.7.0.dist-info/METADATA,sha256=eUE6FIYZGklV_MNFNBDH9CSLQXLXZN5KlNYYkF4cifw,3507
+aws_annoying-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aws_annoying-0.7.0.dist-info/entry_points.txt,sha256=DcKE5V0WvVJ8wUOHxyUz1yLAJOuuJUgRPlMcQ4O7jEs,66
+aws_annoying-0.7.0.dist-info/licenses/LICENSE,sha256=Q5GkvYijQ2KTQ-QWhv43ilzCno4ZrzrEuATEQZd9rYo,1067
+aws_annoying-0.7.0.dist-info/RECORD,,

aws_annoying/ecs/deployment_waiter.py

@@ -1,274 +0,0 @@
-from __future__ import annotations
-
-import logging
-from operator import itemgetter
-from time import sleep
-from typing import TYPE_CHECKING, Optional
-
-import boto3
-import botocore.exceptions
-from pydantic import PositiveInt, validate_call
-
-from .errors import DeploymentFailedError, NoRunningDeploymentError, ServiceTaskDefinitionAssertionError
-
-if TYPE_CHECKING:
-    from .common import ECSServiceRef
-
-logger = logging.getLogger(__name__)
-
-
-class ECSDeploymentWaiter:
-    """ECS service deployment waiter."""
-
-    def __init__(self, service_ref: ECSServiceRef, *, session: boto3.session.Session | None = None) -> None:
-        """Initialize instance.
-
-        Args:
-            service_ref: Reference to the ECS service.
-            session: Boto3 session to use for AWS operations.
-
-        """
-        self.service_ref = service_ref
-        self.session = session or boto3.session.Session()
-
-    @validate_call
-    def wait(
-        self,
-        *,
-        wait_for_start: bool,
-        polling_interval: PositiveInt = 5,
-        wait_for_stability: bool,
-        expected_task_definition: Optional[str] = None,
-    ) -> None:
-        """Wait for the ECS deployment to complete.
-
-        Args:
-            wait_for_start: Whether to wait for the deployment to start.
-            polling_interval: The interval between any polling attempts, in seconds.
-            wait_for_stability: Whether to wait for the service to be stable after the deployment.
-            expected_task_definition: The service's task definition expected after deployment.
-        """
-        # Find current deployment for the service
-        logger.info(
-            "Looking up running deployment for service %s",
-            self.service_ref.service,
-        )
-        latest_deployment_arn = self.get_latest_deployment_arn(
-            wait_for_start=wait_for_start,
-            polling_interval=polling_interval,
-        )
-
-        # Polling for the deployment to finish (successfully or unsuccessfully)
-        logger.info(
-            "Start waiting for deployment %s to finish.",
-            latest_deployment_arn,
-        )
-        ok, status = self.wait_for_deployment_complete(latest_deployment_arn, polling_interval=polling_interval)
-        if ok:
-            logger.info(
-                "Deployment succeeded with status %s",
-                status,
-            )
-        else:
-            msg = f"Deployment failed with status: {status}"
-            raise DeploymentFailedError(msg)
-
-        # Wait for the service to be stable
-        if wait_for_stability:
-            logger.debug(
-                "Start waiting for service %s to be stable.",
-                self.service_ref.service,
-            )
-            self.wait_for_service_stability(polling_interval=polling_interval)
-
-        # Check if the service task definition matches the expected one
-        if expected_task_definition:
-            logger.info(
-                "Checking if the service task definition is the expected one: %s",
-                expected_task_definition,
-            )
-            ok, actual = self.check_service_task_definition_is(expect=expected_task_definition)
-            if not ok:
-                msg = f"The service task definition is not the expected one; got: {actual!r}"
-                raise ServiceTaskDefinitionAssertionError(msg)
-
-            logger.info("The service task definition matches the expected one.")
-
-    @validate_call
-    def get_latest_deployment_arn(
-        self,
-        *,
-        wait_for_start: bool,
-        polling_interval: PositiveInt,
-        max_attempts: Optional[PositiveInt] = None,
-    ) -> str:
-        """Get the most recently started deployment ARN for the service.
-
-        Args:
-            wait_for_start: Whether to wait for the deployment to start.
-            polling_interval: The interval between any polling attempts, in seconds.
-            max_attempts: The maximum number of attempts to wait for the deployment to start.
-
-        Raises:
-            NoRunningDeploymentError: If no running deployments are found and `wait_for_start` is False.
-
-        Returns:
-            The ARN of the latest deployment for the service.
-        """
-        ecs = self.session.client("ecs")
-        if wait_for_start:
-            logger.warning("`wait_for_start` is set, will wait for a new deployment to start.")
-
-        attempts = 0
-        while True:  # do-while
-            # Do
-            running_deployments = ecs.list_service_deployments(
-                cluster=self.service_ref.cluster,
-                service=self.service_ref.service,
-                status=["PENDING", "IN_PROGRESS"],
-            )["serviceDeployments"]
-
-            # While
-            if running_deployments:
-                logger.debug("Found %d running deployments for service. Exiting loop.", len(running_deployments))
-                break
-
-            if not wait_for_start:
-                logger.debug("`wait_for_start` is off, no need to wait for a new deployment to start.")
-                break
-
-            if max_attempts and attempts >= max_attempts:
-                logger.debug("Max attempts exceeded while waiting for a new deployment to start.")
-                break
-
-            logger.debug(
-                "(%d-th attempt) No running deployments found for service. Start waiting for a new deployment.",
-                attempts + 1,
-            )
-
-            sleep(polling_interval)
-            attempts += 1
-
-        if not running_deployments:
-            msg = "No running deployments found for service."
-            raise NoRunningDeploymentError(msg)
-
-        latest_deployment = sorted(running_deployments, key=itemgetter("startedAt"))[-1]
-        if len(running_deployments) > 1:
-            logger.warning(
-                "%d running deployments found for service. Using most recently started deployment: %s",
-                len(running_deployments),
-                latest_deployment["serviceDeploymentArn"],
-            )
-
-        return latest_deployment["serviceDeploymentArn"]
-
-    @validate_call
-    def wait_for_deployment_complete(
-        self,
-        deployment_arn: str,
-        *,
-        polling_interval: PositiveInt,
-        max_attempts: Optional[PositiveInt] = None,
-    ) -> tuple[bool, str]:
-        """Wait for the ECS deployment to complete.
-
-        Args:
-            deployment_arn: The ARN of the deployment to wait for.
-            polling_interval: The interval between any polling attempts, in seconds.
-            max_attempts: The maximum number of attempts to wait for the deployment to complete.
-
-        Returns:
-            A tuple containing a boolean indicating whether the deployment succeeded and the status of the deployment.
-        """
-        ecs = self.session.client("ecs")
-
-        attempts = 0
-        while (max_attempts is None) or (attempts <= max_attempts):
-            latest_deployment = ecs.describe_service_deployments(serviceDeploymentArns=[deployment_arn])[
-                "serviceDeployments"
-            ][0]
-            status = latest_deployment["status"]
-            if status == "SUCCESSFUL":
-                return (True, status)
-
-            if status in ("PENDING", "IN_PROGRESS"):
-                logger.debug(
-                    "(%d-th attempt) Deployment in progress... (%s)",
-                    attempts + 1,
-                    status,
-                )
-            else:
-                break
-
-            sleep(polling_interval)
-            attempts += 1
-
-        return (False, status)
-
-    @validate_call
-    def wait_for_service_stability(
-        self,
-        *,
-        polling_interval: PositiveInt,
-        max_attempts: Optional[PositiveInt] = None,
-    ) -> bool:
-        """Wait for the ECS service to be stable.
-
-        Args:
-            polling_interval: The interval between any polling attempts, in seconds.
-            max_attempts: The maximum number of attempts to wait for the service to be stable.
-
-        Returns:
-            A boolean indicating whether the service is stable.
-        """
-        ecs = self.session.client("ecs")
-
-        # TODO(lasuillard): Likely to be a problem in some cases: https://github.com/boto/botocore/issues/3314
-        stability_waiter = ecs.get_waiter("services_stable")
-
-        attempts = 0
-        while (max_attempts is None) or (attempts <= max_attempts):
-            logger.debug(
-                "(%d-th attempt) Waiting for service %s to be stable...",
-                attempts + 1,
-                self.service_ref.service,
-            )
-            try:
-                stability_waiter.wait(
-                    cluster=self.service_ref.cluster,
-                    services=[self.service_ref.service],
-                    WaiterConfig={"Delay": polling_interval, "MaxAttempts": 1},
-                )
-            except botocore.exceptions.WaiterError as err:
-                if err.kwargs["reason"] != "Max attempts exceeded":
-                    raise
-            else:
-                return True
-
-            sleep(polling_interval)
-            attempts += 1
-
-        return False
-
-    @validate_call
-    def check_service_task_definition_is(self, expect: str) -> tuple[bool, str]:
-        """Check the service's current task definition matches the expected one.
-
-        Args:
-            expect: The ARN of expected task definition.
-
-        Returns:
-            A tuple containing a boolean indicating whether the task definition matches the expected one
-            and the current task definition ARN.
-        """
-        ecs = self.session.client("ecs")
-
-        service_detail = ecs.describe_services(cluster=self.service_ref.cluster, services=[self.service_ref.service])[
-            "services"
-        ][0]
-        current_task_definition_arn = service_detail["taskDefinition"]
-        if current_task_definition_arn != expect:
-            return (False, current_task_definition_arn)
-
-        return (True, current_task_definition_arn)