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

aws_annoying/cli/app.py

@@ -8,6 +8,10 @@ from typing import Optional
 import typer
 from rich import print  # noqa: A004
 from rich.console import Console
+from rich.highlighter import ReprHighlighter
+from rich.theme import Theme
+
+logger = logging.getLogger(__name__)
 
 app = typer.Typer(
     pretty_exceptions_short=True,
@@ -51,7 +55,7 @@ def main(  # noqa: D103
     ),
 ) -> None:
     log_level = logging.DEBUG if verbose else logging.INFO
-    console = Console(soft_wrap=True, emoji=False)
+    console = _get_console()
     logging_config: logging.config._DictConfigArgs = {
         "version": 1,
         "disable_existing_loggers": False,
@@ -89,3 +93,28 @@ def main(  # noqa: D103
 
     # Global flags
     ctx.meta["dry_run"] = dry_run
+    if dry_run:
+        logger.warning("Dry run mode enabled. Some operation may behave differently to avoid making changes.")
+
+
+def _get_console() -> Console:
+    theme = Theme(
+        {
+            "repr.arn": "bold orange3",
+            "repr.constant": "bold blue",
+        },
+    )
+    return Console(soft_wrap=True, emoji=False, highlighter=CustomHighlighter(), theme=theme)
+
+
+class CustomHighlighter(ReprHighlighter):
+    """Custom highlighter to handle additional patterns."""
+
+    highlights = [  # noqa: RUF012
+        *ReprHighlighter.highlights,
+        # AWS Resource Name; https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html
+        # NOTE: Quite simplified regex, may not cover all cases.
+        r"(?P<arn>\barn:[0-9a-zA-Z/+=,\.@_\-:]+\b)",
+        # Constants
+        r"(?P<constant>\b[A-Z_]+\b)",
+    ]

aws_annoying/cli/ecs/task_definition_lifecycle.py

@@ -40,9 +40,6 @@ def task_definition_lifecycle(
 ) -> None:
     """Execute ECS task definition lifecycle."""
     dry_run = ctx.meta["dry_run"]
-    if dry_run:
-        logger.info("Dry run mode enabled. Will not perform any actual changes.")
-
     ecs = boto3.client("ecs")
 
     # Get all task definitions for the family

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/cli/logging_handler.py

@@ -15,10 +15,10 @@ class RichLogHandler(logging.Handler):
 
     _level_emojis: Final[dict[str, str]] = {
         "DEBUG": "🔍",
-        "INFO": "ℹ️",  # noqa: RUF001
+        "INFO": "🔔",
         "WARNING": "⚠️",
-        "ERROR": "❗",
-        "CRITICAL": "🚨",
+        "ERROR": "🚨",
+        "CRITICAL": "🔥",
     }
 
     def __init__(self, console: Console, *args: Any, **kwargs: Any) -> None:

aws_annoying/cli/mfa/configure.py

@@ -17,6 +17,7 @@ logger = logging.getLogger(__name__)
 
 @mfa_app.command()
 def configure(  # noqa: PLR0913
+    ctx: typer.Context,
     *,
     mfa_profile: Optional[str] = typer.Option(
         None,
@@ -54,6 +55,8 @@ def configure(  # noqa: PLR0913
     ),
 ) -> None:
     """Configure AWS profile for MFA."""
+    dry_run = ctx.meta["dry_run"]
+
     # Expand user home directory
     aws_credentials = aws_credentials.expanduser()
     aws_config = aws_config.expanduser()
@@ -102,13 +105,14 @@ def configure(  # noqa: PLR0913
         mfa_profile,
         aws_credentials,
     )
-    update_credentials(
-        aws_credentials,
-        mfa_profile,  # type: ignore[arg-type]
-        access_key=credentials["AccessKeyId"],
-        secret_key=credentials["SecretAccessKey"],
-        session_token=credentials["SessionToken"],
-    )
+    if not dry_run:
+        update_credentials(
+            aws_credentials,
+            mfa_profile,  # type: ignore[arg-type]
+            access_key=credentials["AccessKeyId"],
+            secret_key=credentials["SecretAccessKey"],
+            session_token=credentials["SessionToken"],
+        )
 
     # Persist MFA configuration
     if persist:
@@ -120,6 +124,7 @@ def configure(  # noqa: PLR0913
         mfa_config.mfa_profile = mfa_profile
         mfa_config.mfa_source_profile = mfa_source_profile
         mfa_config.mfa_serial_number = mfa_serial_number
-        mfa_config.save_ini_file(aws_config, aws_config_section)
+        if not dry_run:
+            mfa_config.save_ini_file(aws_config, aws_config_section)
     else:
         logger.warning("MFA configuration not persisted.")

aws_annoying/cli/session_manager/install.py

@@ -15,12 +15,15 @@ logger = logging.getLogger(__name__)
 # https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html
 @session_manager_app.command()
 def install(
-    yes: bool = typer.Option(  # noqa: FBT001
+    ctx: typer.Context,
+    *,
+    yes: bool = typer.Option(
         False,  # noqa: FBT003
         help="Do not ask confirmation for installation.",
     ),
 ) -> None:
     """Install AWS Session Manager plugin."""
+    dry_run = ctx.meta["dry_run"]
     session_manager = SessionManager()
 
     # Check session-manager-plugin already installed
@@ -31,7 +34,8 @@ def install(
 
     # Install session-manager-plugin
     logger.warning("Installing AWS Session Manager plugin. You could be prompted for admin privileges request.")
-    session_manager.install(confirm=yes, downloader=TQDMDownloader())
+    if not dry_run:
+        session_manager.install(confirm=yes, downloader=TQDMDownloader())
 
     # Verify installation
     is_installed, binary_path, version = session_manager.verify_installation()

aws_annoying/cli/session_manager/port_forward.py

@@ -19,6 +19,8 @@ logger = logging.getLogger(__name__)
 # https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html
 @session_manager_app.command()
 def port_forward(  # noqa: PLR0913
+    ctx: typer.Context,
+    *,
     # TODO(lasuillard): Add `--local-host` option, redirect the traffic to non-localhost bind (unsupported by AWS)
     local_port: int = typer.Option(
         ...,
@@ -48,7 +50,7 @@ def port_forward(  # noqa: PLR0913
         "./session-manager-plugin.pid",
         help="The path to the PID file to store the process ID of the session manager plugin.",
     ),
-    terminate_running_process: bool = typer.Option(  # noqa: FBT001
+    terminate_running_process: bool = typer.Option(
         False,  # noqa: FBT003
         help="Terminate the process in the PID file if it already exists.",
     ),
@@ -58,6 +60,7 @@ def port_forward(  # noqa: PLR0913
     ),
 ) -> None:
     """Start a port forwarding session using AWS Session Manager."""
+    dry_run = ctx.meta["dry_run"]
     session_manager = SessionManager()
 
     # Check if the PID file already exists
@@ -86,7 +89,7 @@ def port_forward(  # noqa: PLR0913
         logger.info("Instance ID resolved: [bold]%s[/bold]", instance_id)
         target = instance_id
     else:
-        logger.info("Instance with name '%s' not found.", through)
+        logger.error("Instance with name '%s' not found.", through)
         raise typer.Exit(1)
 
     # Initiate the session
@@ -111,19 +114,26 @@ def port_forward(  # noqa: PLR0913
         through,
         reason,
     )
-    proc = subprocess.Popen(  # noqa: S603
-        command,
-        stdout=stdout,
-        stderr=subprocess.STDOUT,
-        text=True,
-        close_fds=False,  # FD inherited from parent process
-    )
+    if not dry_run:
+        proc = subprocess.Popen(  # noqa: S603
+            command,
+            stdout=stdout,
+            stderr=subprocess.STDOUT,
+            text=True,
+            close_fds=False,  # FD inherited from parent process
+        )
+        pid = proc.pid
+    else:
+        pid = -1
+
     logger.info(
         "Session Manager Plugin started with PID %d. Outputs will be logged to %s.",
-        proc.pid,
+        pid,
         log_file.absolute(),
     )
 
     # Write the PID to the file
-    pid_file.write_text(str(proc.pid))
+    if not dry_run:
+        pid_file.write_text(str(pid))
+
     logger.info("PID file written to %s.", pid_file.absolute())

aws_annoying/cli/session_manager/start.py

@@ -18,6 +18,8 @@ logger = logging.getLogger(__name__)
 
 @session_manager_app.command()
 def start(
+    ctx: typer.Context,
+    *,
     target: str = typer.Option(
         ...,
         show_default=False,
@@ -29,6 +31,7 @@ def start(
     ),
 ) -> None:
     """Start new session."""
+    dry_run = ctx.meta["dry_run"]
     session_manager = SessionManager()
 
     # Resolve the instance name or ID
@@ -52,4 +55,5 @@ def start(
         parameters={},
         reason=reason,
     )
-    os.execvp(command[0], command)  # noqa: S606
+    if not dry_run:
+        os.execvp(command[0], command)  # noqa: S606

aws_annoying/cli/session_manager/stop.py

@@ -14,16 +14,20 @@ logger = logging.getLogger(__name__)
 
 @session_manager_app.command()
 def stop(
+    ctx: typer.Context,
+    *,
     pid_file: Path = typer.Option(  # noqa: B008
         "./session-manager-plugin.pid",
         help="The path to the PID file to store the process ID of the session manager plugin.",
     ),
-    remove: bool = typer.Option(  # noqa: FBT001
+    remove: bool = typer.Option(
         True,  # noqa: FBT003
         help="Remove the PID file after stopping the session.",
     ),
 ) -> None:
     """Stop running session for PID file."""
+    dry_run = ctx.meta["dry_run"]
+
     # Check if PID file exists
     if not pid_file.is_file():
         logger.error("PID file not found: %s", pid_file)
@@ -40,13 +44,15 @@ def stop(
     # Send SIGTERM to the process
     try:
         logger.warning("Terminating running process with PID %d.", pid)
-        os.kill(pid, signal.SIGTERM)
+        if not dry_run:
+            os.kill(pid, signal.SIGTERM)
     except ProcessLookupError:
         logger.warning("Tried to terminate process with PID %d but does not exist.", pid)
 
     # Remove the PID file
     if remove:
         logger.info("Removed the PID file %s.", pid_file)
-        pid_file.unlink()
+        if not dry_run:
+            pid_file.unlink()
 
     logger.info("Terminated the session successfully.")

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.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-annoying
-Version: 0.6.0
+Version: 0.8.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.8.0.dist-info}/RECORD

@@ -2,40 +2,41 @@ aws_annoying/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aws_annoying/mfa_config.py,sha256=z0GpRhLHEWaaXbECV4Ei4oNM1WCFoEZAxCIPbpY4Ymc,2200
 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/logging_handler.py,sha256=JPsZePV3YH9e1nLv0Q3fqSeXSEfZ5cGJo6eLK2F4oxE,1426
+aws_annoying/cli/app.py,sha256=W0FPz0N7okjENwaGpdoWRhcei5Xs-uxSMRaYldaza3M,3295
+aws_annoying/cli/load_variables.py,sha256=n5CIci_uAoGaOZ4EKIKEEfcyMq81Hjy9AFOXq1-Hbh0,4896
+aws_annoying/cli/logging_handler.py,sha256=z2fBHChHiyzQeKtKjykX-JvuWm57gARB3VDmpQSdu6U,1409
 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/task_definition_lifecycle.py,sha256=COGYy5o9N6J7tv6aA7qhT-4WsAoxbyPC1UMPtKKrPpg,2704
+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
+aws_annoying/cli/mfa/configure.py,sha256=Lfmc4VKkUGngbrbxLRrgcEv-vyPM_-1ne_G4U-Vh7Mg,4092
 aws_annoying/cli/session_manager/__init__.py,sha256=FkT6jT6OXduOURN61d-U6hgd-XluQbvuVtKXXiXgSEk,105
 aws_annoying/cli/session_manager/_app.py,sha256=OVOHW0iyKzunvaqLhjoseHw1-WxJ1gGb7QmiyAEezyY,221
 aws_annoying/cli/session_manager/_common.py,sha256=Uj-MF7z8Qntd24Z03xxE-jSKcgrsd8xl41E6db4qCtY,711
-aws_annoying/cli/session_manager/install.py,sha256=VIk6313jUf6THwvs06AOUQwhTjzCGCcvDXMxyz0BcgE,1477
-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/cli/session_manager/install.py,sha256=QA88qIu7aYTlBN0tqU-lEN5nMGpshXF3jddBBCZixV8,1550
+aws_annoying/cli/session_manager/port_forward.py,sha256=7tSaGlcoSpJ9G2NYHvcC-PpmVqz-I4B4T8e4Xe45BE8,4495
+aws_annoying/cli/session_manager/start.py,sha256=p4vGUIT4IivJp_Sr7yYljRuYTDHBWULt2Av6AzAjL1I,1536
+aws_annoying/cli/session_manager/stop.py,sha256=SrjGJdodTmcGK1OPyFX61vWzJTqgfsuBRFvScIdYJCU,1641
+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.8.0.dist-info/METADATA,sha256=PDr5RneXMjRUQglP8tSmNSpBatkPyK3uJilJpm1RISo,3507
+aws_annoying-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aws_annoying-0.8.0.dist-info/entry_points.txt,sha256=DcKE5V0WvVJ8wUOHxyUz1yLAJOuuJUgRPlMcQ4O7jEs,66
+aws_annoying-0.8.0.dist-info/licenses/LICENSE,sha256=Q5GkvYijQ2KTQ-QWhv43ilzCno4ZrzrEuATEQZd9rYo,1067
+aws_annoying-0.8.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)