djd 0.1.0__py3-none-any.whl

deploy/__init__.py

@@ -0,0 +1,3 @@
+from deploy.logging import initialize_logging
+
+initialize_logging(log_name="deploy")

deploy/aws.py

@@ -0,0 +1,108 @@
+import logging
+import os
+import pty
+import subprocess
+import traceback
+
+from botocore.exceptions import BotoCoreError, ClientError
+
+from deploy.config import AWS_REGION
+
+
+def describe_service_deployments(client, cluster: str, services: list[str]):
+    describe_services_response = client.describe_services(cluster=cluster, services=services)
+
+    all_deployment_updates = []
+    for response in describe_services_response["services"]:
+        service_name = response["serviceName"]
+        deployment_updates = response["deployments"]
+        latest_deployment_id = next(reversed(sorted(deployment_updates, key=lambda x: x["createdAt"])))["id"]
+
+        for deployment_update in deployment_updates:
+            deployment_update["service"] = service_name
+            deployment_update["is_latest"] = latest_deployment_id == deployment_update["id"]
+            all_deployment_updates.append(deployment_update)
+
+    return all_deployment_updates
+
+
+def describe_service_tasks(client, cluster: str, services: list[str] | None = None):
+    task_ids = []
+    if services:
+        for service in services:
+            list_tasks_response = client.list_tasks(cluster=cluster, serviceName=service)
+            task_ids += list_tasks_response["taskArns"]
+    else:
+        list_tasks_response = client.list_tasks(cluster=cluster)
+        task_ids += list_tasks_response["taskArns"]
+
+    tasks = []
+    if task_ids:
+        describe_tasks_response = client.describe_tasks(cluster=cluster, tasks=task_ids)
+        tasks = describe_tasks_response["tasks"]
+
+    return tasks
+
+
+def execute_command(client, command: str, cluster: str, service: str, interactive: bool = False):
+    list_tasks_response = client.list_tasks(cluster=cluster, serviceName=service)
+    task_ids = list_tasks_response["taskArns"]
+
+    # TODO: exec command in most recent task (sort first)
+
+    if len(task_ids):
+        task_id = task_ids[0]
+
+        logging.info("Starting Interactive Session...")
+        cmd = ["aws", "ecs", "execute-command", "--cluster", cluster, "--region",
+               AWS_REGION, "--task", task_id, "--interactive", "--command", f"'{command}'"]
+        logging.info(f'Running Command: \n"{(" ").join(cmd)}"')
+
+        try:
+            if interactive:
+                pty.spawn(cmd)
+            else:
+                subprocess.run(
+                    cmd,
+                    check=True,
+                    text=True,
+                    capture_output=True
+                )
+
+        except subprocess.CalledProcessError as e:
+            traceback.print_exception(e)
+            logging.error("Command failed")
+
+    else:
+        logging.info("No running task")
+
+
+def copy_ecr_image(
+    client,
+    source_repo_name: str,
+    target_repo_name: str,
+    image_tag: str = "latest",
+):
+    try:
+        # Get the image manifest from the source repo
+        get_response = client.batch_get_image(repositoryName=source_repo_name, imageIds=[{"imageTag": image_tag}])
+
+        if not get_response["images"]:
+            raise RuntimeError("Image not found in source repo")
+
+        image = get_response["images"][0]
+        manifest = image["imageManifest"]
+        media_type = image.get("imageManifestMediaType", "application/vnd.docker.distribution.manifest.v2+json")
+
+        # Push the manifest to the target repo
+        client.put_image(
+            repositoryName=target_repo_name,
+            imageManifest=manifest,
+            imageTag=image_tag,
+            imageManifestMediaType=media_type,
+        )
+
+    except (ClientError, BotoCoreError):
+        return False
+
+    return True

deploy/cli/deploy.py

@@ -0,0 +1,428 @@
+import logging
+import os
+import subprocess
+import time
+from collections import defaultdict
+from pathlib import Path
+
+import typer
+from deploy.config import (
+    AWS_REGION,
+    DEFAULT_SERVICES,
+    DOCKERFILE_PATH,
+    GIT_COPY_PATH,
+    MIGRATION_TIMEOUT_SECONDS,
+    TERRAFORM_PATH,
+)
+
+from deploy.context import DeployContext, DeployContextObj
+from deploy.history import DeployHistoryType
+from deploy.renderables.tables import (
+    DeployHistoryTable,
+    ECSDeploymentStatusTable,
+    ECSTaskStatusTable,
+)
+from deploy.renderables.util import RenderableDatetime
+from rich import print
+
+app = typer.Typer(name="deploy", help="Manage AWS ECS deployments.")
+
+
+@app.callback()
+def initialize(
+    ctx: typer.Context,
+    environment: str,
+    debug: bool = False,
+    confirm: bool = False,
+    refresh: float = 1.0,
+    docker_context_path: Path = GIT_COPY_PATH,
+    github_workflow: bool = False,
+):
+    ctx.obj = DeployContextObj(
+        environment,
+        debug=debug,
+        confirm=confirm,
+        refresh=refresh,
+        docker_context_path=docker_context_path,
+        github_workflow=github_workflow,
+    )
+
+
+@app.command(help="Run a generic Terraform command for the specified deployment.")
+def tf(
+    ctx: DeployContext,
+    command: str = typer.Argument(..., help="Terraform subcommand (e.g. plan, apply)"),
+    terraform_args: list[str] = typer.Argument(None, help="Extra args to pass to terraform", hidden=True),
+):
+    subprocess.run(
+        ["terraform", command] + (terraform_args or []),
+        cwd=os.path.join(TERRAFORM_PATH, "deployments", ctx.obj.environment),
+        check=True,
+    )
+
+
+@app.command(help="Log-in to AWS ECR instance with Docker.")
+def docker_login(
+    ctx: DeployContext,
+):
+    ecr_image_uri = ctx.obj.terraform["ecr_image_uri"]
+
+    logging.info("Logging into ECR...")
+    password = subprocess.check_output(
+        ["aws", "ecr", "get-login-password", "--region", AWS_REGION],
+        text=True,
+    )
+    subprocess.check_output(
+        ["docker", "login", "--username", "AWS", "--password-stdin", ecr_image_uri],
+        input=password,
+        text=True,
+    )
+    logging.info("Logged in to ECR successfully")
+
+
+@app.command(help="Build docker image for specified environment.")
+def docker_build(
+    ctx: DeployContext,
+    branch: str = "main",
+    push: bool = True,
+    cache: bool = True,
+) -> bool:
+    ctx.invoke(docker_login, ctx=ctx)
+
+    # Determine ECR Repo
+    ecr_image_uri = ctx.obj.terraform["ecr_image_uri"]
+    ecr_cache_uri = ecr_image_uri.replace(":latest", ":cache")
+
+    # Build and upload docker image
+    logging.info(f'Building docker image "{ecr_image_uri}"...')
+    build_command = [
+        "docker", "buildx", "build",
+        str(ctx.obj.docker_context_path),
+        "--platform=linux/amd64",
+        "--provenance=false",
+        "--sbom=false",
+        "-t", ecr_image_uri,
+    ]
+
+    # Pull latest code
+    if ctx.obj.docker_context_path != ".":
+        ctx.obj.git.pull(branch)
+        git_info = ctx.obj.git.get_info()
+        build_command += [
+            "--build-arg",
+            f"COMMIT_HASH_MAIN={git_info['commit']['hexsha']}",
+        ]
+
+    if cache:
+        build_command += [
+            f"--cache-from=type=registry,ref={ecr_cache_uri}",
+            f"--cache-to=type=registry,ref={ecr_cache_uri},mode=max,image-manifest=true,oci-mediatypes=true",
+        ]
+    else:
+        build_command += ["--no-cache"]
+
+    if push:
+        build_command += ["--push"]
+
+    build_command += ["-f", DOCKERFILE_PATH]
+
+    logging.info(f"Running: {(' ').join(build_command)}")
+
+    build_process = subprocess.run(build_command)
+    if build_process.returncode != 0:
+        logging.error("Failed to build image.")
+        return False
+
+    if push:
+        ctx.obj.log(DeployHistoryType.docker_image)
+
+    return True
+
+
+@app.command(help="Show ECS Services for a specified environment.")
+def show_services(
+    ctx: DeployContext,
+    services: list[str] = typer.Argument(None, help="List of ECS services to target"),
+):
+    deployments = ctx.obj.describe_service_deployments(services)
+    print(ECSDeploymentStatusTable(deployments))
+
+
+@app.command(help="Show tasks for a specified environment.")
+def show_tasks(
+    ctx: DeployContext,
+    services: list[str] = typer.Argument(None, help="List of ECS services to target"),
+):
+    tasks = ctx.obj.describe_service_tasks(services)
+    print(ECSTaskStatusTable(tasks))
+
+
+@app.command(help="Watch deployments for a specified environment.")
+def watch_deployments(
+    ctx: DeployContext,
+    services: list[str] = typer.Argument(None, help="List of ECS services to target"),
+):
+    status = defaultdict(dict)
+    status_keys_watched = ["status", "rolloutState", "runningCount", "desiredCount"]
+
+    table = ECSDeploymentStatusTable()
+    watched_deployments = set()
+    deployment_updates = ctx.obj.describe_service_deployments(services)
+    for deployment_update in reversed(sorted(deployment_updates, key=lambda x: x["createdAt"])):
+        status[deployment_update["id"]] = deployment_update
+        table.add_entry(deployment_update)
+        if deployment_update.get("is_latest"):
+            watched_deployments.add(deployment_update["id"])
+
+    print(table)
+
+    try:
+        while True:
+            changed = False
+            removed = set(status.keys())
+
+            deployment_updates = ctx.obj.describe_service_deployments(services)
+            for deployment_update in deployment_updates:
+                # Add deployment to status (Another task has added this deployment)
+                if deployment_update["id"] not in removed:
+                    status[deployment_update["id"]] = deployment_update
+                    changed = True
+
+                else:
+                    removed.remove(deployment_update["id"])
+
+                deployment = status[deployment_update["id"]]
+                for key in status_keys_watched:
+                    if deployment_update[key] != deployment.get(key, None):
+                        deployment[key] = deployment_update[key]
+                        changed = True
+
+            for removed_deployment in removed:
+                status.pop(removed_deployment)
+
+            if changed:
+                table = ECSDeploymentStatusTable(show_header=False, title=RenderableDatetime.now())
+                for deployment in reversed(sorted(status.values(), key=lambda x: x["createdAt"])):
+                    table.add_entry(deployment)
+
+                    # Check if watched deployments are successful
+                    if (
+                        deployment["rolloutState"] == "COMPLETED"
+                        and deployment["id"] in watched_deployments
+                        and deployment["runningCount"] == deployment["desiredCount"]
+                    ):
+                        watched_deployments.remove(deployment["id"])
+
+                print(table)
+
+            # Terminate when all watched deployments are complete
+            if not watched_deployments:
+                logging.info('Deployment completed successfully')
+                return True
+
+            time.sleep(ctx.obj.refresh)
+
+    except KeyboardInterrupt:
+        logging.info('Skipping "watch_deployments"')
+        return False
+
+
+@app.command(help="Deploy specified EC2 service.")
+def force_deploy(
+    ctx: DeployContext,
+    services: list[str] = typer.Argument(None, help="List of ECS services to target"),
+):
+    logging.info(f"Force-deploying environment {ctx.obj.environment}")
+
+    if ctx.obj.confirm:
+        deployments = ctx.obj.describe_service_deployments(services)
+        print(ECSDeploymentStatusTable(deployments))
+
+    if ctx.obj.get_confirmation("Force deploy?"):
+        logging.info("Updating Service(s)...")
+
+        for service in services:
+            ctx.obj.update_service(service=service, forceNewDeployment=True)
+
+        # Poll for deployment updating successfully
+        if ctx.invoke(watch_deployments, ctx=ctx, services=services):
+            ctx.obj.log(DeployHistoryType.deployment)
+            pass
+
+
+@app.command(help="Show the current deployment state and history")
+def history(
+    ctx: DeployContext,
+    raw: bool = False,
+):
+    logging.info(f'Environment "{ctx.obj.environment}" deployment history:')
+
+    if raw:
+        print(ctx.obj.history)
+    else:
+        entries = ctx.obj.history[ctx.obj.environment]
+        print(DeployHistoryTable(entries))
+
+
+@app.command(help="Open an interactive shell in the latest task instance in the specified environment.")
+def ssh(
+    ctx: DeployContext,
+    service: str = "web",
+):
+    ctx.obj.execute_command("/bin/bash", service, interactive=True)
+
+
+@app.command(help="Run a django management command in the latest task instance in the specified environment.")
+def manage(
+    ctx: DeployContext,
+    service: str = "web",
+    command: list[str] = typer.Argument(..., help="Django management command, (e.g., 'shell_plus', etc.)"),
+):
+    # TODO: Allow the user the option to kick off a new container using `run_task` for long-running jobs
+    cmd = f"uv run manage.py {(' '.join(command))}"
+    ctx.obj.execute_command(cmd, service, interactive=True)
+
+
+@app.command(help="Run migrations on a specified deployment database.")
+def run_migrations(
+    ctx: DeployContext,
+    service: str = "web",
+):
+    deployments = ctx.obj.describe_service_deployments(services=[service])
+
+    if ctx.obj.confirm or ctx.obj.debug:
+        print(ECSDeploymentStatusTable(deployments))
+
+    if ctx.obj.get_confirmation("Run Migration?"):
+        run_task_response = ctx.obj.run_task(service, "uv run manage.py migrate --no-input")
+        if not run_task_response:
+            logging.info("Migration Failed")
+            return False
+
+        logging.info("Waiting for task to start...")
+
+        migration_task_arn = run_task_response["tasks"][0]["taskArn"]
+        describe_tasks_response = ctx.obj.describe_tasks(task_arns=[migration_task_arn])
+        task = describe_tasks_response["tasks"][0]
+        status_keys_watched = ["lastStatus", "healthStatus"]
+        print(ECSTaskStatusTable(entries=[task]))
+
+        started, stopped = None, None
+        start = time.perf_counter()
+        while time.perf_counter() - start < MIGRATION_TIMEOUT_SECONDS:
+            describe_tasks_response = ctx.obj.describe_tasks(task_arns=[migration_task_arn])
+            new_task = describe_tasks_response["tasks"][0]
+
+            if any([task[key] != new_task[key] for key in status_keys_watched]):
+                print(
+                    ECSTaskStatusTable(
+                        entries=[new_task],
+                        show_header=False,
+                        title=RenderableDatetime.now(),
+                    )
+                )
+
+            task = new_task
+
+            if not started:
+                started = task.get("startedAt")
+                if started:
+                    logging.info(f"Task started at {started}")
+
+            if not stopped:
+                stopped = task.get("stoppedAt")
+                if stopped:
+                    logging.info(f"Task stopped at {stopped}")
+
+            if task.get("stopCode") == "EssentialContainerExited":
+                logging.info("Migration Successful")
+                ctx.obj.log(DeployHistoryType.migration)
+                return True
+
+            elif task.get("stopCode") == "TaskFailedToStart":
+                logging.info("Migration task failed to start. Exiting...")
+                break
+
+            elif task.get("stopCode"):
+                logging.info("Migration Task stopcode:")
+                logging.info(task.get("stopCode"))
+                break
+
+            time.sleep(ctx.obj.refresh)
+
+        logging.info("Migration Failed")
+        return False
+
+
+@app.command(help="Set selected service to desired_count = 0.")
+def stop_service(
+    ctx: DeployContext,
+    environment: str,
+    services: list[str] = typer.Argument(None, help="List of ECS services to target"),
+):
+    logging.info(f"Stopping service(s) {services} on environment {environment}")
+
+    if ctx.obj.confirm or ctx.obj.debug:
+        deployments = ctx.obj.describe_service_deployments(services)
+        print(ECSDeploymentStatusTable(deployments))
+
+    if ctx.obj.get_confirmation("Stop Service(s)?"):
+        logging.info("Updating Service(s)...")
+
+        for service in services:
+            ctx.obj.update_service(service=service, desiredCount=0)
+
+
+@app.command(help="Run entire deployment process.")
+def run_deployment(
+    ctx: DeployContext,
+    service: str = "web",
+    services: list[str] = typer.Argument(None, help="List of ECS services to target"),
+    branch: str = "main",
+    push: bool = True,
+    cache: bool = True,
+    migration: bool = True,
+    build: bool = True,
+    promote_image: str | None = None,
+):
+    services = services or DEFAULT_SERVICES
+
+    if ctx.obj.github_workflow:
+        ctx.obj.git.dispatch_github_workflow(
+            "deploy",
+            {
+                "services": (" ").join(services),
+                "environment": ctx.obj.environment,
+                "branch": branch,
+                "migration": migration,
+            },
+        )
+        return True
+
+    # Build docker container from git code, or promote an image from a separate ECR repo
+    if promote_image:
+        ctx.obj.promote_image(promote_image)
+    elif build:
+        build_result = ctx.invoke(docker_build, ctx=ctx, branch=branch, push=push, cache=cache)
+        if not build_result:
+            logging.error("Failed to build image, aborting deployment.")
+            return
+
+    # Poll for the migration task completing successfully (abort whole deploy if it fails)
+    # Force deploy immediately if no-migrations is set
+    if migration:
+        migration_result = ctx.invoke(
+            run_migrations,
+            ctx=ctx,
+            service=service,
+        )
+        if not migration_result:
+            logging.error("Failed to run migrations, aborting deployment.")
+            return
+
+    # Force a new deployment on selected services
+    ctx.invoke(force_deploy, ctx=ctx, services=services)
+
+
+def main():
+    app()

deploy/cli/templates.py

@@ -0,0 +1,118 @@
+import logging
+from pathlib import Path
+
+from rich import print
+import typer
+from deploy.config import AWS_REGION
+from deploy.renderables.util import render_diff
+from deploy.terraform import TEMPLATES_DIR, diff_templates, render_templates
+
+app = typer.Typer(name="templates", help="Manage infrastructure templates. (AWS, Terraform, etc.)")
+
+
+@app.command(help="Initialize deployment by copying template files to local repository.")
+def init(
+    name: str,
+    aws_profile: str = "default",
+    aws_state_bucket: str = "terraform-states",
+    tf_module: str = "application",
+):
+    context = {
+        "name": name,
+        "aws_profile": aws_profile,
+        "aws_region": AWS_REGION,
+        "aws_state_bucket": aws_state_bucket,
+        "tf_module": tf_module,
+    }
+
+    for rendered_content, output_path in render_templates(context):
+        # If rendered path already exists, skip
+        if output_path.exists():
+            logging.warning(f"Skipped {output_path} (already exists)")
+            continue
+
+        # Ensure parent directories exist
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write the file
+        output_path.write_text(rendered_content)
+        logging.info(f"Created file {output_path}")
+
+    logging.info(f"Deployment '{name}' created")
+
+
+@app.command(help="Add a subset of templates to local repository.")
+def add(
+    templates_dir: str,
+    aws_profile: str = "default",
+    aws_state_bucket: str = "terraform-states",
+    tf_module: str = "application",
+):
+    context = {
+        "aws_profile": aws_profile,
+        "aws_region": AWS_REGION,
+        "aws_state_bucket": aws_state_bucket,
+        "tf_module": tf_module,
+    }
+
+    for rendered_content, output_path in render_templates(context, templates_dir):
+        # If rendered path already exists, skip
+        if output_path.exists():
+            logging.warning(f"Skipped {output_path} (already exists)")
+            continue
+
+        # Ensure parent directories exist
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write the file
+        output_path.write_text(rendered_content)
+        logging.info(f"Created file {output_path}")
+
+    logging.info(f"Added templates from '{templates_dir}'")
+
+
+@app.command(help="Update deployment templates, overwriting files.")
+def update(
+    name: str,
+    templates_dir: str,
+    aws_profile: str = "default",
+    aws_state_bucket: str = "terraform-states",
+    tf_module: str = "application",
+    dry_run: bool = False,
+):
+    context = {
+        "name": name,
+        "aws_profile": aws_profile,
+        "aws_region": AWS_REGION,
+        "aws_state_bucket": aws_state_bucket,
+        "tf_module": tf_module,
+    }
+
+    for rendered_content, output_path in render_templates(context, templates_dir):
+        if "main.tf" in str(output_path):
+            continue
+
+        # Ensure parent directories exist
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Check for existing file and print diff if it exists
+        modified_files, created_files = 0, 0
+        if output_path.exists():
+            if diff := diff_templates(rendered_content, output_path):
+                if not dry_run:
+                    output_path.write_text(rendered_content)
+                    modified_files += 1
+                logging.info(f'Modified "{output_path}"')
+                print(render_diff(diff, str(output_path)))
+        else:
+            if not dry_run:
+                output_path.write_text(rendered_content)
+                created_files += 1
+            logging.info(f'Created file "{output_path}"')
+
+    logging.info(f"{modified_files} files were modified and {created_files} files were created.")
+    logging.info(f"Deployment '{name}' Updated")
+
+
+def main():
+    app()

deploy/config.py

@@ -0,0 +1,42 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Load .env from config/.env as a fallback
+config_env_path = Path("config/.env")
+if config_env_path.exists():
+    load_dotenv(dotenv_path=config_env_path, override=False)
+
+
+# Use env variables if set, otherwise fall back to defaults
+DEPLOY_PATH = Path(os.getenv("DEPLOY_PATH", ".deploy"))
+STATE_PATH = Path(os.getenv("STATE_PATH", DEPLOY_PATH / Path("state.json")))
+HISTORY_PATH = Path(os.getenv("HISTORY_PATH", DEPLOY_PATH / Path("history.json")))
+GIT_COPY_PATH = Path(os.getenv("GIT_COPY_PATH", ".git-copy"))
+TERRAFORM_PATH = Path(os.getenv("TERRAFORM_PATH", "terraform"))
+AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
+AWS_PROFILE = os.getenv("AWS_PROFILE", "zag-dev-cli")
+MIGRATION_TIMEOUT_SECONDS = float(os.getenv("MIGRATION_TIMEOUT_SECONDS", 10 * 60))
+REMOTE_REPO_NAME = os.getenv("REMOTE_REPO_NAME", "zagaran/sample-django-app")
+REMOTE_REPO_URL = os.getenv("REMOTE_REPO_URL", f"git@github.com:{REMOTE_REPO_NAME}.git")
+DOCKERFILE_PATH = os.getenv("DOCKERFILE_PATH", "Dockerfile")
+DEFAULT_SERVICES = os.getenv("DEFAULT_SERVICES", "web,worker").split(",")
+
+# Documentation --
+# Definitely set AWS_PROFILE, AWS_REGION, and REMOTE_REPO_NAME
+
+# TODO: Fix getting `settings.py` from django -- this should be optional somehow
+# # Assume user runs code from their project root, otherwise they need to set `PROJECT_ROOT` variable
+# PROJECT_ROOT = os.environ.get("PROJECT_ROOT") or os.getcwd()
+# if PROJECT_ROOT not in sys.path:
+#     sys.path.insert(0, PROJECT_ROOT)
+#
+# os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+#
+# try:
+#     django.setup()
+# except ModuleNotFoundError:
+#     pass