aws-annoying 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

aws_annoying/ecs_task_definition_lifecycle.py

@@ -1,11 +1,18 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 import boto3
 import typer
 from rich import print  # noqa: A004
 
 from .app import app
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+_DELETE_CHUNK_SIZE = 10
+
 
 @app.command()
 def ecs_task_definition_lifecycle(
@@ -22,6 +29,10 @@ def ecs_task_definition_lifecycle(
         min=1,
         max=100,
     ),
+    delete: bool = typer.Option(
+        False,  # noqa: FBT003
+        help="Delete the task definition after deregistering it.",
+    ),
     dry_run: bool = typer.Option(
         False,  # noqa: FBT003
         help="Do not perform any changes, only show what would be done.",
@@ -48,6 +59,7 @@ def ecs_task_definition_lifecycle(
 
     # Keep the latest N task definitions
     expired_taskdef_arns = task_definition_arns[:-keep_latest]
+    print(f"⚠️ Deregistering {len(expired_taskdef_arns)} task definitions...")
     for arn in expired_taskdef_arns:
         if not dry_run:
             ecs.deregister_task_definition(taskDefinition=arn)
@@ -55,3 +67,18 @@ def ecs_task_definition_lifecycle(
         # ARN like: "arn:aws:ecs:<region>:<account-id>:task-definition/<family>:<revision>"
         _, family_revision = arn.split(":task-definition/")
         print(f"✅ Deregistered task definition [yellow]{family_revision!r}[/yellow]")
+
+    if delete and expired_taskdef_arns:
+        # Delete the expired task definitions in chunks due to API limitation
+        print(f"⚠️ Deleting {len(expired_taskdef_arns)} task definitions in chunks of size {_DELETE_CHUNK_SIZE}...")
+        for idx, chunk in enumerate(_chunker(expired_taskdef_arns, _DELETE_CHUNK_SIZE)):
+            if not dry_run:
+                ecs.delete_task_definitions(taskDefinitions=chunk)
+
+            print(f"✅ Deleted {len(chunk)} task definitions in {idx}-th batch.")
+
+
+def _chunker(sequence: list, size: int) -> Iterator[list]:
+    """Yield successive chunks of a given size from the sequence."""
+    for i in range(0, len(sequence), size):
+        yield sequence[i : i + size]

aws_annoying/main.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import aws_annoying.ecs_task_definition_lifecycle
 import aws_annoying.load_variables
 import aws_annoying.mfa
+import aws_annoying.session_manager
 from aws_annoying.utils.debugger import input_as_args
 
 # App with all commands registered

aws_annoying/session_manager/__init__.py

@@ -0,0 +1,3 @@
+from . import install, port_forward, start, stop
+
+__all__ = ("install", "port_forward", "start", "stop")

aws_annoying/session_manager/_app.py

@@ -0,0 +1,9 @@
+import typer
+
+from aws_annoying.app import app
+
+session_manager_app = typer.Typer(
+    no_args_is_help=True,
+    help="AWS Session Manager CLI utilities.",
+)
+app.add_typer(session_manager_app, name="session-manager")

aws_annoying/session_manager/_common.py

@@ -0,0 +1,24 @@
+# TODO(lasuillard): Using this file until split CLI from library codebase
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from rich.prompt import Confirm
+
+from .session_manager import SessionManager as _SessionManager
+
+
+# Custom session manager with console interactivity
+class SessionManager(_SessionManager):
+    def before_install(self, command: list[str]) -> None:
+        if self._confirm:
+            return
+
+        confirm = Confirm.ask(f"⚠️ Will run the following command: [bold red]{' '.join(command)}[/bold red]. Proceed?")
+        if not confirm:
+            raise typer.Abort
+
+    def install(self, *args: Any, confirm: bool = False, **kwargs: Any) -> None:
+        self._confirm = confirm
+        return super().install(*args, **kwargs)

aws_annoying/session_manager/errors.py

@@ -0,0 +1,10 @@
+class SessionManagerError(Exception):
+    """Base exception for all errors related to Session Manager."""
+
+
+class UnsupportedPlatformError(SessionManagerError):
+    """Exception raised when the platform is not supported."""
+
+
+class PluginNotInstalledError(SessionManagerError):
+    """Trying to use the Session Manager plugin before it is installed."""

aws_annoying/session_manager/install.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import typer
+from rich import print  # noqa: A004
+
+from aws_annoying.utils.downloader import TQDMDownloader
+
+from ._app import session_manager_app
+from ._common import SessionManager
+
+
+# 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
+        False,  # noqa: FBT003
+        help="Do not ask confirmation for installation.",
+    ),
+) -> None:
+    """Install AWS Session Manager plugin."""
+    session_manager = SessionManager(downloader=TQDMDownloader())
+
+    # Check session-manager-plugin already installed
+    is_installed, binary_path, version = session_manager.verify_installation()
+    if is_installed:
+        print(f"✅ Session Manager plugin is already installed at {binary_path} (version: {version})")
+        return
+
+    # Install session-manager-plugin
+    print("⬇️ Installing AWS Session Manager plugin. You could be prompted for admin privileges request.")
+    session_manager.install(confirm=yes)
+
+    # Verify installation
+    is_installed, binary_path, version = session_manager.verify_installation()
+    if not is_installed:
+        print("❌ Installation failed. Session Manager plugin not found.")
+        raise typer.Exit(1)
+
+    print(f"✅ Session Manager plugin successfully installed at {binary_path} (version: {version})")

aws_annoying/session_manager/port_forward.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import os
+import re
+import signal
+from pathlib import Path  # noqa: TC003
+
+import boto3
+import typer
+from rich import print  # noqa: A004
+
+from aws_annoying.utils.downloader import TQDMDownloader
+
+from ._app import session_manager_app
+from ._common import SessionManager
+
+
+# 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
+    # TODO(lasuillard): Add `--local-host` option, redirect the traffic to non-localhost bind (unsupported by AWS)
+    local_port: int = typer.Option(
+        ...,
+        show_default=False,
+        help="The local port to use for port forwarding.",
+    ),
+    through: str = typer.Option(
+        ...,
+        show_default=False,
+        help="The name or ID of the EC2 instance to use as a proxy for port forwarding.",
+    ),
+    remote_host: str = typer.Option(
+        ...,
+        show_default=False,
+        help="The remote host to connect to.",
+    ),
+    remote_port: int = typer.Option(
+        ...,
+        show_default=False,
+        help="The remote port to connect to.",
+    ),
+    reason: str = typer.Option(
+        "",
+        help="The reason for starting the port forwarding session.",
+    ),
+    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.",
+    ),
+    terminate_running_process: bool = typer.Option(  # noqa: FBT001
+        False,  # noqa: FBT003
+        help="Terminate the process in the PID file if it already exists.",
+    ),
+    log_file: Path = typer.Option(  # noqa: B008
+        "./session-manager-plugin.log",
+        help="The path to the log file to store the output of the session manager plugin.",
+    ),
+) -> None:
+    """Start a port forwarding session using AWS Session Manager."""
+    session_manager = SessionManager(downloader=TQDMDownloader())
+
+    # Check if the PID file already exists
+    if pid_file.exists():
+        if not terminate_running_process:
+            print("🚫 PID file already exists.")
+            raise typer.Exit(1)
+
+        pid_content = pid_file.read_text()
+        try:
+            existing_pid = int(pid_content)
+        except ValueError:
+            print(f"🚫 PID file content is invalid; expected integer, but got: {type(pid_content)}")
+            raise typer.Exit(1) from None
+
+        try:
+            print(f"⚠️ Terminating running process with PID {existing_pid}.")
+            os.kill(existing_pid, signal.SIGTERM)
+            pid_file.write_text("")  # Clear the PID file
+        except ProcessLookupError:
+            print(f"⚠️ Tried to terminate process with PID {existing_pid} but does not exist.")
+
+    # Resolve the instance name or ID
+    if re.match(r"m?i-.+", through):
+        target = through
+    else:
+        # If the instance name is provided, get the instance ID
+        instance_id = _get_instance_id_by_name(through)
+        if instance_id:
+            print(f"❗ Instance ID resolved: [bold]{instance_id}[/bold]")
+        else:
+            print(f"🚫 Instance with name '{through}' not found.")
+            raise typer.Exit(1)
+
+        target = instance_id
+
+    # Initiate the session
+    proc = session_manager.start(
+        target=target,
+        document_name="AWS-StartPortForwardingSessionToRemoteHost",
+        parameters={
+            "host": [remote_host],
+            "portNumber": [str(remote_port)],
+            "localPortNumber": [str(local_port)],
+        },
+        reason=reason,
+    )
+    print(f"✅ Session Manager Plugin started with PID {proc.pid}. Outputs will be logged to {log_file.absolute()}.")
+
+    # Write the PID to the file
+    pid_file.write_text(str(proc.pid))
+    print(f"💾 PID file written to {pid_file.absolute()}.")
+
+
+def _get_instance_id_by_name(name: str) -> str | None:
+    """Get the EC2 instance ID by name."""
+    ec2 = boto3.client("ec2")
+    response = ec2.describe_instances(Filters=[{"Name": "tag:Name", "Values": [name]}])
+    reservations = response["Reservations"]
+    if not reservations:
+        return None
+
+    instances = reservations[0]["Instances"]
+    if not instances:
+        return None
+
+    return str(instances[0]["InstanceId"])

aws_annoying/session_manager/session_manager.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import platform
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+import boto3
+
+from aws_annoying.utils.platform import command_as_root, is_root, os_release
+
+from .errors import PluginNotInstalledError, UnsupportedPlatformError
+
+if TYPE_CHECKING:
+    from aws_annoying.utils.downloader import AbstractDownloader
+
+logger = logging.getLogger(__name__)
+
+# TODO(lasuillard): Platform checking is spread everywhere, should be moved to a single place
+
+
+class SessionManager:
+    """AWS Session Manager plugin manager."""
+
+    def __init__(self, *, session: boto3.session.Session | None = None, downloader: AbstractDownloader) -> None:
+        """Initialize SessionManager.
+
+        Args:
+            session: Boto3 session to use for AWS operations.
+            downloader: File downloader to use for downloading the plugin.
+        """
+        self.session = session or boto3.session.Session()
+        self.downloader = downloader
+
+    # ------------------------------------------------------------------------
+    # Installation
+    # ------------------------------------------------------------------------
+    def verify_installation(self) -> tuple[bool, Path | None, str | None]:
+        """Verify installation of AWS Session Manager plugin.
+
+        Returns:
+            3-tuple of boolean flag indicating whether plugin installed, binary path and version string.
+        """
+        # Find plugin binary
+        if not (binary_path := self._get_binary_path()):
+            return False, None, None
+
+        # Check version
+        result_bytes = subprocess.run(  # noqa: S603
+            [str(binary_path), "--version"],
+            check=True,
+            capture_output=True,
+        )
+        result = result_bytes.stdout.decode().strip()
+        if not bool(re.match(r"[\d\.]+", result)):
+            return False, binary_path, result
+
+        return True, binary_path, result
+
+    def _get_binary_path(self) -> Path | None:
+        """Get the path to the session-manager-plugin binary."""
+        binary_path_str = shutil.which("session-manager-plugin")
+        if not binary_path_str:
+            if platform.system() == "Windows":
+                # Windows: use the default installation path
+                binary_path = (
+                    Path(os.environ["ProgramFiles"])  # noqa: SIM112
+                    / "Amazon"
+                    / "SessionManagerPlugin"
+                    / "bin"
+                    / "session-manager-plugin.exe"
+                )
+                if binary_path.is_file():
+                    return binary_path.absolute()
+
+            return None
+
+        return Path(binary_path_str).absolute()
+
+    def install(
+        self,
+        *,
+        os: str | None = None,
+        linux_distribution: _LinuxDistribution | None = None,
+        arch: str | None = None,
+        root: bool | None = None,
+    ) -> None:
+        """Install AWS Session Manager plugin.
+
+        Args:
+            os: The operating system to install the plugin on. If `None`, will use the current operating system.
+            linux_distribution: The Linux distribution to install the plugin on.
+                If `None` and current `os` is `"Linux"`, will try to detect the distribution from current system.
+            arch: The architecture to install the plugin on. If `None`, will use the current architecture.
+            root: Whether to run the installation as root. If `None`, will check if the current user is root.
+        """
+        os = os or platform.system()
+        arch = arch or platform.machine()
+
+        if os == "Windows":
+            self._install_windows()
+        elif os == "Darwin":
+            self._install_macos(arch=arch, root=root or is_root())
+        elif os == "Linux":
+            linux_distribution = linux_distribution or _detect_linux_distribution()
+            self._install_linux(linux_distribution=linux_distribution, arch=arch, root=root or is_root())
+        else:
+            msg = f"Unsupported operating system: {os}"
+            raise UnsupportedPlatformError(msg)
+
+    def before_install(self, command: list[str]) -> None:
+        """Hook to run before invoking plugin installation command."""
+
+    # https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-windows.html
+    def _install_windows(self) -> None:
+        """Install session-manager-plugin on Windows via EXE installer."""
+        download_url = (
+            "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/windows/SessionManagerPluginSetup.exe"
+        )
+        with tempfile.TemporaryDirectory() as temp_dir:
+            p = Path(temp_dir)
+            exe_installer = self.downloader.download(download_url, to=p / "SessionManagerPluginSetup.exe")
+            command = [str(exe_installer), "/quiet"]
+            self.before_install(command)
+            subprocess.call(command, cwd=p)  # noqa: S603
+
+    # https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-macos-overview.html
+    def _install_macos(self, *, arch: str, root: bool) -> None:
+        """Install session-manager-plugin on macOS via signed installer."""
+        # ! Intel chip will not be supported
+        if arch == "x86_64":
+            download_url = (
+                "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/mac/session-manager-plugin.pkg"
+            )
+        elif arch == "arm64":
+            download_url = (
+                "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/mac_arm64/session-manager-plugin.pkg"
+            )
+        else:
+            msg = f"Architecture {arch} not supported for macOS"
+            raise UnsupportedPlatformError(msg)
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            p = Path(temp_dir)
+            pkg_installer = self.downloader.download(download_url, to=p / "session-manager-plugin.pkg")
+
+            # Run installer
+            command = command_as_root(
+                ["installer", "-pkg", str(pkg_installer), "-target", "/"],
+                root=root,
+            )
+            self.before_install(command)
+            subprocess.call(command, cwd=p)  # noqa: S603
+
+            # Symlink
+            command = [
+                "ln",
+                "-s",
+                "/usr/local/sessionmanagerplugin/bin/session-manager-plugin",
+                "/usr/local/bin/session-manager-plugin",
+            ]
+            if not root:
+                command = ["sudo", *command]
+
+            logger.info("Running %s to create symlink", " ".join(command))
+            Path("/usr/local/bin").mkdir(exist_ok=True)
+            subprocess.call(command, cwd=p)  # noqa: S603
+
+    # https://docs.aws.amazon.com/systems-manager/latest/userguide/install-plugin-linux-overview.html
+    def _install_linux(
+        self,
+        *,
+        linux_distribution: _LinuxDistribution,
+        arch: str,
+        root: bool,
+    ) -> None:
+        name = linux_distribution.name
+        version = linux_distribution.version
+
+        # Debian / Ubuntu
+        if name in ("debian", "ubuntu"):
+            logger.info("Detected Linux distribution: Debian / Ubuntu")
+
+            # Download installer
+            url_map = {
+                "x86_64": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_64bit/session-manager-plugin.deb",
+                "x86": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_32bit/session-manager-plugin.deb",
+                "arm64": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_arm64/session-manager-plugin.deb",
+            }
+            download_url = url_map.get(arch)
+            if not download_url:
+                msg = f"Architecture {arch} not supported for distribution {name}"
+                raise UnsupportedPlatformError(msg)
+
+            with tempfile.TemporaryDirectory() as temp_dir:
+                p = Path(temp_dir)
+                deb_installer = self.downloader.download(download_url, to=p / "session-manager-plugin.deb")
+
+                # Invoke installation command
+                command = command_as_root(["dpkg", "--install", str(deb_installer)], root=root)
+                self.before_install(command)
+                subprocess.call(command, cwd=p)  # noqa: S603
+
+        # Amazon Linux / RHEL
+        elif name in ("amzn", "rhel"):
+            logger.info("Detected Linux distribution: Amazon Linux / RHEL")
+
+            # Determine package URL and package manager
+            url_map = {
+                "x86_64": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_64bit/session-manager-plugin.rpm",
+                "x86": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_32bit/session-manager-plugin.rpm",
+                "arm64": "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/linux_arm64/session-manager-plugin.rpm",
+            }
+            package_url = url_map.get(arch)
+            if not package_url:
+                msg = f"Architecture {arch} not supported for distribution {name}"
+                raise UnsupportedPlatformError(msg)
+
+            use_yum = (
+                # Amazon Linux 2
+                name == "amzn" and version.startswith("2")
+            ) or (
+                # RHEL 7 Maipo (8 Ootpa / 9 Plow)
+                name == "rhel" and "Maipo" in version
+            )  # ... else use dnf
+            package_manager = "yum" if use_yum else "dnf"
+
+            # Invoke installation command
+            command = command_as_root([package_manager, "install", "-y", package_url], root=root)
+            self.before_install(command)
+            subprocess.call(command)  # noqa: S603
+
+        else:
+            msg = f"Unsupported distribution: {name}"
+            raise UnsupportedPlatformError(msg)
+
+    # ------------------------------------------------------------------------
+    # Session
+    # ------------------------------------------------------------------------
+    def start(
+        self,
+        *,
+        target: str,
+        document_name: str,
+        parameters: dict[str, Any],
+        reason: str | None = None,
+        log_file: Path | None = None,
+    ) -> subprocess.Popen:
+        """Start new session.
+
+        Args:
+            target: The target instance ID or name.
+            document_name: The SSM document name to use for the session.
+            parameters: The parameters to pass to the SSM document.
+            reason: The reason for starting the session.
+            log_file: Optional file to log output to.
+
+        Returns:
+            Process ID of the session.
+        """
+        is_installed, binary_path, version = self.verify_installation()
+        if not is_installed:
+            msg = "Session Manager plugin is not installed."
+            raise PluginNotInstalledError(msg)
+
+        ssm = self.session.client("ssm")
+        response = ssm.start_session(
+            Target=target,
+            DocumentName=document_name,
+            Parameters=parameters,
+            # ? Reason is optional but it doesn't allow empty string or `None`
+            **({"Reason": reason} if reason else {}),
+        )
+
+        region = self.session.region_name
+        command = [
+            str(binary_path),
+            json.dumps(response),
+            region,
+            "StartSession",
+            self.session.profile_name,
+            json.dumps({"Target": target}),
+            f"https://ssm.{region}.amazonaws.com",
+        ]
+
+        stdout: subprocess._FILE
+        if log_file is not None:  # noqa: SIM108
+            stdout = log_file.open(mode="at+", buffering=1)
+        else:
+            stdout = subprocess.DEVNULL
+
+        return subprocess.Popen(  # noqa: S603
+            command,
+            stdout=stdout,
+            stderr=subprocess.STDOUT,
+            text=True,
+            close_fds=False,  # FD inherited from parent process
+        )
+
+
+# ? Could be moved to utils, but didn't because it's too specific to this module
+class _LinuxDistribution(NamedTuple):
+    name: str
+    version: str
+
+
+def _detect_linux_distribution() -> _LinuxDistribution:
+    """Autodetect current Linux distribution."""
+    osr = os_release()
+    name = osr.get("ID", "").lower()
+    version = osr.get("VERSION", "")
+    return _LinuxDistribution(name=name, version=version)

aws_annoying/session_manager/start.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from ._app import session_manager_app
+
+
+@session_manager_app.command()
+def start() -> None:
+    """Start new session."""
+    # TODO(lasuillard): To be implemented (maybe in #24?)

aws_annoying/session_manager/stop.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import os
+import signal
+from pathlib import Path  # noqa: TC003
+
+import typer
+from rich import print  # noqa: A004
+
+from ._app import session_manager_app
+
+
+@session_manager_app.command()
+def stop(
+    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
+        True,  # noqa: FBT003
+        help="Remove the PID file after stopping the session.",
+    ),
+) -> None:
+    """Stop running session for PID file."""
+    # Check if PID file exists
+    if not pid_file.is_file():
+        print(f"❌ PID file not found: {pid_file}")
+        raise typer.Exit(1)
+
+    # Read PID from file
+    pid_content = pid_file.read_text()
+    try:
+        pid = int(pid_content)
+    except ValueError:
+        print(f"🚫 PID file content is invalid; expected integer, but got: {type(pid_content)}")
+        raise typer.Exit(1) from None
+
+    # Send SIGTERM to the process
+    try:
+        print(f"⚠️ Terminating running process with PID {pid}.")
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        print(f"❗ Tried to terminate process with PID {pid} but does not exist.")
+
+    # Remove the PID file
+    if remove:
+        print(f"✅ Removed the PID file {pid_file}.")
+        pid_file.unlink()
+
+    print("✅ Terminated the session successfully.")

aws_annoying/utils/downloader.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+import requests
+from tqdm import tqdm
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class AbstractDownloader(ABC):
+    """Abstract downloader class for downloading files."""
+
+    @abstractmethod
+    def download(self, url: str, *, to: Path) -> Path:
+        """Download file from URL to path."""
+
+
+class DummyDownloader(AbstractDownloader):
+    """Dummy downloader that does nothing (mainly for testing purposes)."""
+
+    def download(self, url: str, *, to: Path) -> Path:
+        """Download file from URL to path."""
+        logger.debug("Dummy downloader called for URL (%s) to %s.", url, to)
+        return to.absolute()
+
+
+class TQDMDownloader(AbstractDownloader):
+    """Downloader with TQDM progress bar."""
+
+    def download(self, url: str, *, to: Path) -> Path:
+        """Download file from URL to path."""
+        # https://gist.github.com/yanqd0/c13ed29e29432e3cf3e7c38467f42f51
+        logger.info("Downloading file from URL (%s) to %s.", url, to)
+        with requests.get(url, stream=True, timeout=10) as response:
+            response.raise_for_status()
+            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,
+            ):
+                for chunk in response.iter_content(chunk_size=8_192):
+                    size = f.write(chunk)
+                    pbar.update(size)
+
+        return to.absolute()

aws_annoying/utils/platform.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def command_as_root(command: list[str], *, root: bool | None = None) -> list[str]:
+    """Modify a command to run as root (`sudo`) if not already running as root."""
+    root = root or is_root()
+    if not root:
+        command = ["sudo", *command]
+
+    return command
+
+
+def is_root() -> bool:
+    """Check if the current user is root."""
+    return os.geteuid() == 0
+
+
+def os_release() -> dict[str, str]:
+    """Parse `/etc/os-release` file into a dictionary."""
+    content = Path("/etc/os-release").read_text()
+    return {
+        key.strip('"'): value.strip('"')
+        for key, value in (line.split("=", 1) for line in content.splitlines() if "=" in line)
+    }

{aws_annoying-0.2.1.dist-info → aws_annoying-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws-annoying
-Version: 0.2.1
+Version: 0.3.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
@@ -11,11 +11,14 @@ License-File: LICENSE
 Requires-Python: <4.0,>=3.9
 Requires-Dist: boto3>=1.37.1
 Requires-Dist: pydantic>=2.10.6
+Requires-Dist: requests>=2.32.3
+Requires-Dist: tqdm>=4.67.1
 Requires-Dist: typer>=0.15.1
 Provides-Extra: dev
-Requires-Dist: boto3-stubs[ecs,secretsmanager,ssm,sts]>=1.37.1; 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: ruff<0.12.0,>=0.9.9; extra == 'dev'
+Requires-Dist: types-requests>=2.31.0.6; extra == 'dev'
 Provides-Extra: test
 Requires-Dist: coverage<7.9,>=7.6; extra == 'test'
 Requires-Dist: moto[ecs,secretsmanager,server,ssm]~=5.1.1; extra == 'test'

aws_annoying-0.3.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+aws_annoying/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aws_annoying/app.py,sha256=sp50uVoAl4D6Wk3DFpzKZzSsxmSxNYejFxm62b_Kxps,201
+aws_annoying/ecs_task_definition_lifecycle.py,sha256=O36Bf5LBnVJNyYmdlUxhtsIHNoxky1t5YacAXiL9UEI,2803
+aws_annoying/load_variables.py,sha256=380xT1i85HWybgOIWn72xGCDgqYJ2OSa9VOKMlyHg8M,9488
+aws_annoying/main.py,sha256=lWvPCEnm_N9Sx9LA_YDoGHmbCyYWDhkg-UHyt8i-GLY,487
+aws_annoying/mfa/__init__.py,sha256=rbEGhw5lOQZV_XAc3nSbo56JVhsSPpeOgEtiAy9qzEA,50
+aws_annoying/mfa/_app.py,sha256=hpa1Bfx8lRsuZfujM-RyaYU5llOuwGKgf4FwEydthU0,185
+aws_annoying/mfa/configure.py,sha256=i5e0qZBFYafuv3D59eP_JXOMrWSRW_bZp0xgIpOlaPE,5364
+aws_annoying/session_manager/__init__.py,sha256=FkT6jT6OXduOURN61d-U6hgd-XluQbvuVtKXXiXgSEk,105
+aws_annoying/session_manager/_app.py,sha256=89brd-3hEe8ECpJ9Z-ANcOqvduFxbPVA-gqJ50Zr_kU,217
+aws_annoying/session_manager/_common.py,sha256=UzCBDvxVymiZP7t2B65sNi1ZVL6HA67GAkKwIYIFZPI,780
+aws_annoying/session_manager/errors.py,sha256=YioKlRtZ-GUP0F_ts_ebw7-HYkxe8mTes6HK821Kuiw,353
+aws_annoying/session_manager/install.py,sha256=zX2cu-IBYlf9yl8z9P0CTQz72BP6aAMo-KnolC_PGsU,1443
+aws_annoying/session_manager/port_forward.py,sha256=uMcsafTNAHZh-0E1yWXCliMivWyuWV2K9DdVhBZ9pG8,4327
+aws_annoying/session_manager/session_manager.py,sha256=7tqfFPA4bWF0Me_VbUDcq5Cpl1sw3bevGyT8QWfLTOk,12454
+aws_annoying/session_manager/start.py,sha256=1yaMuy-7IWrrDoPHjgygOP_-g_tajfnpaVPZanxsZxs,215
+aws_annoying/session_manager/stop.py,sha256=ttU6nlbVgBkZDtY-DwUyCstv5TFtat5TljkyuY8QICU,1482
+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/platform.py,sha256=h3DUWmTMM-_4TfTWNqY0uNqyVsBjAuMm2DEbG-daxe8,742
+aws_annoying-0.3.0.dist-info/METADATA,sha256=H6ciT2fBTifIqg0yYSP5IyfK_CaSzl6f1QI_9ktZjMU,1926
+aws_annoying-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aws_annoying-0.3.0.dist-info/entry_points.txt,sha256=s0l5LK26zEUxLRkBHH9Bu5aH1bOPvYVoTMnUcFlzjm8,62
+aws_annoying-0.3.0.dist-info/licenses/LICENSE,sha256=Q5GkvYijQ2KTQ-QWhv43ilzCno4ZrzrEuATEQZd9rYo,1067
+aws_annoying-0.3.0.dist-info/RECORD,,

aws_annoying-0.2.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-aws_annoying/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aws_annoying/app.py,sha256=sp50uVoAl4D6Wk3DFpzKZzSsxmSxNYejFxm62b_Kxps,201
-aws_annoying/ecs_task_definition_lifecycle.py,sha256=hiypU5RD5moo0KYHn8YRAyGDSMKh-zPnfxfFYWm6w78,1744
-aws_annoying/load_variables.py,sha256=380xT1i85HWybgOIWn72xGCDgqYJ2OSa9VOKMlyHg8M,9488
-aws_annoying/main.py,sha256=jngo15w50Jf6nr63N-yV6AEYsFKYzObJc0wI364zS0s,451
-aws_annoying/mfa/__init__.py,sha256=rbEGhw5lOQZV_XAc3nSbo56JVhsSPpeOgEtiAy9qzEA,50
-aws_annoying/mfa/_app.py,sha256=hpa1Bfx8lRsuZfujM-RyaYU5llOuwGKgf4FwEydthU0,185
-aws_annoying/mfa/configure.py,sha256=i5e0qZBFYafuv3D59eP_JXOMrWSRW_bZp0xgIpOlaPE,5364
-aws_annoying/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aws_annoying/utils/debugger.py,sha256=UFllDCGI2gPtwo1XS5vqw0qyR6bYr7XknmBwSxalKIc,754
-aws_annoying-0.2.1.dist-info/METADATA,sha256=j7HsUgzImczAdXw4L16y6zl0pvwRQEb1sc3dCUClpUk,1806
-aws_annoying-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aws_annoying-0.2.1.dist-info/entry_points.txt,sha256=s0l5LK26zEUxLRkBHH9Bu5aH1bOPvYVoTMnUcFlzjm8,62
-aws_annoying-0.2.1.dist-info/licenses/LICENSE,sha256=Q5GkvYijQ2KTQ-QWhv43ilzCno4ZrzrEuATEQZd9rYo,1067
-aws_annoying-0.2.1.dist-info/RECORD,,