gitops 1.4.0__tar.gz → 1.5.0__tar.gz

{gitops-1.4.0 → gitops-1.5.0}/.release-please-manifest.json

@@ -1,5 +1,5 @@
 {
-    ".": "1.4.0",
+    ".": "1.5.0",
     "gitops_server": "0.15.1",
     "charts/gitops": "1.2.0"
 }

{gitops-1.4.0 → gitops-1.5.0}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [1.5.0](https://github.com/uptick/gitops/compare/gitops-v1.4.1...gitops-v1.5.0) (2025-07-23)
+
+
+### Features
+
+* implement concurrent deployments with per-app serialization ([6d3cc28](https://github.com/uptick/gitops/commit/6d3cc2827c75791aa10d6e12cb60192ed26129d4))
+
+## [1.4.1](https://github.com/uptick/gitops/compare/gitops-v1.4.0...gitops-v1.4.1) (2025-06-04)
+
+
+### Bug Fixes
+
+* make sure to pull the right uv image for the target architecture ([9f9cf51](https://github.com/uptick/gitops/commit/9f9cf51d0d4430f7a535341ff295b003b490d418))
+
 ## [1.4.0](https://github.com/uptick/gitops/compare/gitops-v1.3.1...gitops-v1.4.0) (2025-05-27)
 
 

gitops-1.5.0/CLAUDE.md

@@ -0,0 +1,101 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a GitOps tool for managing multiple applications across Kubernetes clusters. It consists of two main components:
+
+1. **GitOps CLI** (`gitops/`) - Command-line tool for managing app deployments, built using the `invoke` framework
+2. **GitOps Server** (`gitops_server/`) - FastAPI-based webhook server that handles deployment automation
+
+## Development Commands
+
+### Setup
+```bash
+# Install dependencies using uv
+uv sync
+
+# Install the CLI tool for development
+uv tool install -e .
+```
+
+### Testing
+```bash
+# Run all tests
+uv run pytest
+
+# Run specific test file
+uv run pytest tests/test_core.py
+
+# Run with coverage
+uv run pytest --cov=gitops --cov=gitops_server
+```
+
+### Linting and Formatting
+```bash
+# Format code with ruff
+uv run ruff format .
+
+# Lint code
+uv run ruff check .
+
+# Fix auto-fixable linting issues
+uv run ruff check --fix .
+
+# Type checking with mypy
+uv run mypy gitops/ gitops_server/
+```
+
+### Running the CLI
+```bash
+# Run gitops commands during development
+uv run python -m gitops.main --help
+
+# Or if installed globally
+gitops --help
+```
+
+### Running the Server
+```bash
+# Run the gitops server locally
+uv run uvicorn gitops_server.main:app --reload
+```
+
+## Architecture
+
+### CLI Component (`gitops/`)
+- **main.py**: Entry point using invoke's Program framework
+- **core.py**: Main CLI commands (bump, summary, etc.)
+- **shorthands.py**: Shorthand command aliases
+- **settings.py**: Configuration management
+- **utils/**: Helper modules for apps, images, kubernetes operations, CLI formatting, etc.
+
+### Server Component (`gitops_server/`)
+- **main.py**: FastAPI application entry point with webhook endpoint
+- **app.py**: FastAPI app configuration
+- **workers/**: Background workers for deployment operations
+- **workers/deploy.py**: Main deployment loop code
+- **workers/worker.py**: Entry point for recieving webhook
+- **utils/**: Git, GitHub, and Slack integration utilities
+
+### Key Patterns
+- Uses `invoke` framework for CLI task definitions
+- Async operations with progress bars for CLI commands
+- FastAPI with webhook validation for server component
+- Kubernetes operations through the `kubernetes_asyncio` library
+- Git operations for managing cluster repository state
+
+## Configuration
+
+- **Environment Variables**: Set `GITOPS_APPS_DIRECTORY` to specify the apps directory location
+- **Secrets**: Server configuration goes in `secrets.env` (see `secrets.example.env`)
+- **Ruff Config**: Located in `ruff.toml` with specific rules for this codebase
+- **Dependencies**: Managed through `pyproject.toml` with separate server optional dependencies
+
+## Testing Structure
+
+- Tests are in the `tests/` directory
+- Uses pytest with async support (`pytest-asyncio`)
+- Sample data and webhook fixtures in `sample_data.py` and `webhook_sample_data.py`
+- Conftest provides shared test configuration

{gitops-1.4.0 → gitops-1.5.0}/Dockerfile

@@ -1,3 +1,11 @@
+# Stage 1: Define a minimal stage to extract the 'uv' binary
+# This is a multi-stage build to use uv for dependency management and is necessary to ensure the the image version we pull is for the right architecture.
+# This is automatically set by the buildx builder. when using --platoform linux/amd64,linux/arm64 argument and then
+# using FROM in the Dockerfile.
+FROM ghcr.io/astral-sh/uv:0.4.0 AS uv_extractor
+
+
+# Stage 2: The main application build stage
 FROM python:3.12-slim
 
 ARG TARGETARCH
@@ -39,7 +47,11 @@ ENV SHELL=/bin/bash
 ## Install dependencies and copy GitOps server.
 ##
 WORKDIR /app
-COPY --from=ghcr.io/astral-sh/uv:0.4.0 /uv /bin/uv
+
+
+
+# Copy the uv binary from the uv image to the final image.
+COPY --from=uv_extractor /uv /bin/uv
 COPY --link=true pyproject.toml uv.lock /app/
 RUN --mount=type=cache,target=/root/.cache/ \
     (uv sync --frozen --no-install-project --extra server || uv sync --frozen --no-install-project --extra server)

{gitops-1.4.0 → gitops-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitops
-Version: 1.4.0
+Version: 1.5.0
 Summary: Manage multiple apps across one or more k8s clusters.
 Author-email: Jarek Głowacki <jarekwg@gmail.com>
 License-File: LICENSE

{gitops-1.4.0 → gitops-1.5.0}/gitops/__init__.py

@@ -6,7 +6,7 @@ from gitops.utils.apps import App, get_app_details, get_apps
 
 from .utils.cli import success, warning
 
-__version__ = "1.4.0"
+__version__ = "1.5.0"
 
 
 # Checking gitops version matches cluster repo version.

{gitops-1.4.0 → gitops-1.5.0}/gitops/common/app.py

@@ -107,7 +107,7 @@ class App:
         """[610829907584.dkr.ecr.ap-southeast-2.amazonaws.com/uptick:yoink-9f03ac80f3]"""
         image = self.values.get("image", "")
         if isinstance(image, dict):
-            return f"{image['repository']}:{image.get('tag','latest')}"
+            return f"{image['repository']}:{image.get('tag', 'latest')}"
         else:
             return image
 

{gitops-1.4.0 → gitops-1.5.0}/gitops/core.py

@@ -107,7 +107,7 @@ def bump(  # noqa: C901
             print(f"Redeploying {colourise(app_name, Fore.LIGHTGREEN_EX)}")
             update_app(app_name, **{"bump": str(uuid.uuid4())})
         else:
-            print(f"Skipping {colourise(app_name, Fore.LIGHTGREEN_EX)}: already on" f" {colour_image(new_image_tag)}")
+            print(f"Skipping {colourise(app_name, Fore.LIGHTGREEN_EX)}: already on {colour_image(new_image_tag)}")
     if redeploy:
         commit_message = f"Redeploying {filter}"
     else:

{gitops-1.4.0 → gitops-1.5.0}/gitops/utils/async_runner.py

@@ -62,7 +62,7 @@ async def run_tasks_async_with_progress(tasks, max_concurrency=10):
 async def print_async_complete(task, x, y, status_y_offset, win_info, sem):
     cor, name = task
     addstr(win_info, x, y, name)
-    output = f'{"-"*20}\n{progress(name)}\n{"-"*20}\n'
+    output = f"{'-' * 20}\n{progress(name)}\n{'-' * 20}\n"
     try:
         await sem.acquire()
         output += await cor

{gitops-1.4.0 → gitops-1.5.0}/gitops/utils/cli.py

@@ -38,7 +38,7 @@ def confirm(message: str = "") -> bool:
 def confirm_dangerous_command() -> None:
     message = (
         "You are about to execute a dangerous command against a"
-        f" {colourise('production' , Fore.RED)} environment. Please ensure you are pairing with"
+        f" {colourise('production', Fore.RED)} environment. Please ensure you are pairing with"
         " someone else."
     )
     # TODO. Include an actual multi person MFA to proceed.

{gitops-1.4.0 → gitops-1.5.0}/gitops/utils/kube.py

@@ -290,7 +290,7 @@ async def _run_job(
 
 async def wait_for_pod(context: str, namespace: str, pod: str) -> str | None:
     while True:
-        cmd = "kubectl get pod" f" --context {context}" f" -n {namespace}" ' -o jsonpath="{.status.phase}"' f" {pod}"
+        cmd = f'kubectl get pod --context {context} -n {namespace} -o jsonpath="{{.status.phase}}" {pod}'
         stdout, _, _ = await async_run(cmd)
         output = stdout.decode().lower()
         if output != "pending":

gitops-1.5.0/gitops_server/version.py

@@ -0,0 +1 @@
+__version__ = "1.5.0"

{gitops-1.4.0 → gitops-1.5.0}/gitops_server/workers/deployer/deploy.py

@@ -14,6 +14,7 @@ from gitops_server import settings
 from gitops_server.types import AppDefinitions, RunOutput, UpdateAppResult
 from gitops_server.utils import get_repo_name_from_url, github, run, slack
 from gitops_server.utils.git import temp_repo
+from gitops_server.workers.deployer.semaphore_manager import AppSemaphoreManager
 
 from .hooks import handle_failed_deploy, handle_successful_deploy
 
@@ -24,9 +25,13 @@ ROLE_ARN = f"arn:aws:iam::{settings.ACCOUNT_ID}:role/GitopsAccess"
 logger = logging.getLogger("gitops")
 MAX_HELM_HISTORY = 3
 
+# Max parallel helm installs at a time
+# Kube api may rate limit otherwise
+helm_parallel_semaphore = asyncio.Semaphore(int(settings.GITOPS_MAX_PARALLEL_DEPLOYS))
+
 
 @tracer.start_as_current_span("post_result_summary")
-async def post_result_summary(source: str, results: list[UpdateAppResult]):
+async def post_result_summary(source: str, results: list[UpdateAppResult]) -> None:
     n_success = sum([r["exit_code"] == 0 for r in results])
     n_failed = sum([r["exit_code"] != 0 for r in results])
     await slack.post(
@@ -52,6 +57,7 @@ class Deployer:
         commit_message: str,
         current_app_definitions: AppDefinitions,
         previous_app_definitions: AppDefinitions,
+        semaphore_manager: AppSemaphoreManager,
         skip_migrations: bool = False,
     ):
         self.author_name = author_name
@@ -61,9 +67,6 @@ class Deployer:
         self.previous_app_definitions = previous_app_definitions
         self.deploy_id = str(uuid.uuid4())
         self.skip_migrations = skip_migrations
-        # Max parallel helm installs at a time
-        # Kube api may rate limit otherwise
-        self.semaphore = asyncio.Semaphore(int(settings.GITOPS_MAX_PARALLEL_DEPLOYS))
 
         # Track which ones we've deployed and which ones failed
         self.successful_apps: set[str] = set()
@@ -71,9 +74,10 @@ class Deployer:
 
         self.post_ts: str | None = None
         self.skip_deploy = "--skip-deploy" in commit_message
+        self.semaphore_manager = semaphore_manager
 
     @classmethod
-    async def from_push_event(cls, push_event):
+    async def from_push_event(cls, push_event: dict[str, Any], semaphore_manager: AppSemaphoreManager) -> "Deployer":
         url = push_event["repository"]["clone_url"]
         author_name = push_event.get("head_commit", {}).get("author", {}).get("name")
         author_email = push_event.get("head_commit", {}).get("author", {}).get("email")
@@ -91,10 +95,11 @@ class Deployer:
             commit_message,
             current_app_definitions,
             previous_app_definitions,
+            semaphore_manager,
             skip_migrations,
         )
 
-    async def deploy(self):
+    async def deploy(self) -> None:
         if self.skip_deploy:
             logger.info("Skipping deploy due to `--skip-deploy` flag.")
             return
@@ -122,20 +127,22 @@ class Deployer:
         uninstall_results = await asyncio.gather(
             *[self.uninstall_app(self.previous_app_definitions.apps[app_name]) for app_name in self.removed_apps]
         )
-        await post_result_summary(self.current_app_definitions.name, update_results + uninstall_results)
+        without_nones = [r for r in update_results + uninstall_results if r is not None]
+        await post_result_summary(self.current_app_definitions.name, without_nones)
 
     async def uninstall_app(self, app: App) -> UpdateAppResult:
         with tracer.start_as_current_span("uninstall_app", attributes={"app": app.name}):
-            async with self.semaphore:
-                logger.info(f"Uninstalling app {app.name!r}.")
-                result = await run(f"helm uninstall {app.name} -n {app.namespace}", suppress_errors=True)
-                if result:
-                    update_result = UpdateAppResult(app_name=app.name, slack_message="", **result)
-                await self.post_result(
-                    app=app,
-                    result=update_result,
-                    deployer=self,
-                )
+            async with self.semaphore_manager.app_semaphore(app.name):
+                async with helm_parallel_semaphore:
+                    logger.info(f"Uninstalling app {app.name!r}.")
+                    result = await run(f"helm uninstall {app.name} -n {app.namespace}", suppress_errors=True)
+                    if result:
+                        update_result = UpdateAppResult(app_name=app.name, slack_message="", **result)
+                    await self.post_result(
+                        app=app,
+                        result=update_result,
+                        deployer=self,
+                    )
             return update_result
 
     async def rollback_deployment(self, app: App) -> None:
@@ -150,61 +157,33 @@ class Deployer:
             )
 
     async def update_app_deployment(self, app: App) -> UpdateAppResult | None:
+        async with self.semaphore_manager.app_semaphore(app.name):
+            async with helm_parallel_semaphore:
+                return await self._update_app_deployment(app)
+
+    async def _update_app_deployment(self, app: App) -> UpdateAppResult | None:
         app.set_value("deployment.labels.gitops/deploy_id", self.deploy_id)
         app.set_value("deployment.labels.gitops/status", github.STATUSES.in_progress)
         if github_deployment_url := app.values.get("github/deployment_url"):
             app.set_value("deployment.annotations.github/deployment_url", github_deployment_url)
-        async with self.semaphore:
-            with tracer.start_as_current_span("update_app_deployment", attributes={"app": app.name}) as span:
-                logger.info(f"Deploying app {app.name!r}.")
-                from_timestamp = time.time()
-                if app.chart.type == "git":
-                    span.set_attribute("gitops.chart.type", "git")
-                    assert app.chart.git_repo_url
-                    async with temp_repo(app.chart.git_repo_url, ref=app.chart.git_sha) as chart_folder_path:
-                        with tracer.start_as_current_span("helm_dependency_build"):
-                            await run(f"cd {chart_folder_path}; helm dependency build")
-
-                        with tempfile.NamedTemporaryFile(suffix=".yml") as cfg:
-                            cfg.write(json.dumps(app.values).encode())
-                            cfg.flush()
-                            os.fsync(cfg.fileno())
-
-                            with tracer.start_as_current_span("helm_upgrade"):
-
-                                async def upgrade_helm_git() -> RunOutput:
-                                    result = await run(
-                                        "helm secrets upgrade --create-namespace"
-                                        f" --history-max {MAX_HELM_HISTORY}"
-                                        " --install"
-                                        " --timeout=600s"
-                                        f"{' --set skip_migrations=true' if self.skip_migrations else ''}"
-                                        f" -f {cfg.name}"
-                                        f" --namespace={app.namespace}"
-                                        f" {app.name}"
-                                        f" {chart_folder_path}",
-                                        suppress_errors=True,
-                                    )
-                                    return result
+        with tracer.start_as_current_span("update_app_deployment", attributes={"app": app.name}) as span:
+            logger.info(f"Deploying app {app.name!r}.")
+            from_timestamp = time.time()
+            if app.chart.type == "git":
+                span.set_attribute("gitops.chart.type", "git")
+                assert app.chart.git_repo_url
+                async with temp_repo(app.chart.git_repo_url, ref=app.chart.git_sha) as chart_folder_path:
+                    with tracer.start_as_current_span("helm_dependency_build"):
+                        await run(f"cd {chart_folder_path}; helm dependency build")
 
-                                result = await upgrade_helm_git()
-                                if result["exit_code"] != 0 and "is in progress" in result["output"]:
-                                    await self.rollback_deployment(app)
-                                    result = await upgrade_helm_git()
-
-                elif app.chart.type == "helm":
-                    span.set_attribute("gitops.chart.type", "helm")
                     with tempfile.NamedTemporaryFile(suffix=".yml") as cfg:
                         cfg.write(json.dumps(app.values).encode())
                         cfg.flush()
                         os.fsync(cfg.fileno())
-                        chart_version_arguments = f" --version={app.chart.version}" if app.chart.version else ""
-                        with tracer.start_as_current_span("helm_repo_add"):
-                            await run(f"helm repo add {app.chart.helm_repo} {app.chart.helm_repo_url}")
 
                         with tracer.start_as_current_span("helm_upgrade"):
 
-                            async def upgrade_helm_chart() -> RunOutput:
+                            async def upgrade_helm_git() -> RunOutput:
                                 result = await run(
                                     "helm secrets upgrade --create-namespace"
                                     f" --history-max {MAX_HELM_HISTORY}"
@@ -214,22 +193,54 @@ class Deployer:
                                     f" -f {cfg.name}"
                                     f" --namespace={app.namespace}"
                                     f" {app.name}"
-                                    f" {app.chart.helm_chart} {chart_version_arguments}",
+                                    f" {chart_folder_path}",
                                     suppress_errors=True,
                                 )
                                 return result
 
-                            result = await upgrade_helm_chart()
+                            result = await upgrade_helm_git()
                             if result["exit_code"] != 0 and "is in progress" in result["output"]:
                                 await self.rollback_deployment(app)
-                                result = await upgrade_helm_chart()
-                else:
-                    logger.warning("Local is not implemented yet")
-                    return None
+                                result = await upgrade_helm_git()
+
+            elif app.chart.type == "helm":
+                span.set_attribute("gitops.chart.type", "helm")
+                with tempfile.NamedTemporaryFile(suffix=".yml") as cfg:
+                    cfg.write(json.dumps(app.values).encode())
+                    cfg.flush()
+                    os.fsync(cfg.fileno())
+                    chart_version_arguments = f" --version={app.chart.version}" if app.chart.version else ""
+                    with tracer.start_as_current_span("helm_repo_add"):
+                        await run(f"helm repo add {app.chart.helm_repo} {app.chart.helm_repo_url}")
+
+                    with tracer.start_as_current_span("helm_upgrade"):
+
+                        async def upgrade_helm_chart() -> RunOutput:
+                            result = await run(
+                                "helm secrets upgrade --create-namespace"
+                                f" --history-max {MAX_HELM_HISTORY}"
+                                " --install"
+                                " --timeout=600s"
+                                f"{' --set skip_migrations=true' if self.skip_migrations else ''}"
+                                f" -f {cfg.name}"
+                                f" --namespace={app.namespace}"
+                                f" {app.name}"
+                                f" {app.chart.helm_chart} {chart_version_arguments}",
+                                suppress_errors=True,
+                            )
+                            return result
+
+                        result = await upgrade_helm_chart()
+                        if result["exit_code"] != 0 and "is in progress" in result["output"]:
+                            await self.rollback_deployment(app)
+                            result = await upgrade_helm_chart()
+            else:
+                logger.warning("Local is not implemented yet")
+                return None
 
-                update_result = UpdateAppResult(app_name=app.name, slack_message="", **result)
+            update_result = UpdateAppResult(app_name=app.name, slack_message="", **result)
 
-                await self.post_result(app=app, result=update_result, deployer=self, from_timestamp=from_timestamp)
+            await self.post_result(app=app, result=update_result, deployer=self, from_timestamp=from_timestamp)
             return update_result
 
     def calculate_app_deltas(self) -> tuple[set[str], set[str], set[str]]:

{gitops-1.4.0 → gitops-1.5.0}/gitops_server/workers/deployer/hooks.py

@@ -103,7 +103,7 @@ async def handle_failed_deploy(app: App, result: UpdateAppResult, deployer, **kw
             await find_commiter_slack_user(name=deployer.author_name, email=deployer.author_email) or DEFAULT_USER_GROUP
         )
     slack_user_msg = f" {slack_user} " if slack_user else ""
-    log_msg = f"<{get_dashboard_url(workspace_name=app.name, from_timestamp=kwargs.get("from_timestamp"), to_timestamp=time.time())}|(Deployment Logs)>"
+    log_msg = f"<{get_dashboard_url(workspace_name=app.name, from_timestamp=kwargs.get('from_timestamp'), to_timestamp=time.time())}|(Deployment Logs)>"
     result["slack_message"] = (
         f"Failed to deploy app `{result['app_name']}` for cluster"
         f" `{settings.CLUSTER_NAME}` :rotating_light:"

gitops-1.5.0/gitops_server/workers/deployer/semaphore_manager.py

@@ -0,0 +1,52 @@
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from collections.abc import AsyncGenerator
+
+logger = logging.getLogger("gitops.semaphore")
+
+
+class AppSemaphoreManager:
+    """Manages per-app semaphores to ensure sequential updates per app.
+
+    This ensures that while multiple deployments can run concurrently,
+    any given app is only updated by one deployment at a time.
+    """
+
+    _instance: "AppSemaphoreManager | None" = None
+
+    def __init__(self) -> None:
+        self._app_semaphores: dict[str, asyncio.Semaphore] = {}
+        self._semaphore_lock = asyncio.Lock()
+        self._initialized: bool = True
+
+    async def get_app_semaphore(self, app_name: str) -> asyncio.Semaphore:
+        """Get the semaphore for an app.
+
+        If the semaphore does not exist, create it.
+        """
+        async with self._semaphore_lock:
+            if app_name not in self._app_semaphores:
+                logger.debug(f"Creating new semaphore for app: {app_name}")
+                self._app_semaphores[app_name] = asyncio.Semaphore(1)
+            semaphore = self._app_semaphores[app_name]
+        return semaphore
+
+    @asynccontextmanager
+    async def app_semaphore(self, app_name: str) -> AsyncGenerator[None, None]:
+        """Async context manager to acquire and release a semaphore for the given app.
+
+        Each app gets exactly one semaphore with a limit of 1,
+        ensuring sequential updates per app.
+        """
+        semaphore = await self.get_app_semaphore(app_name)
+        async with semaphore:
+            yield
+
+    def get_locked_apps(self) -> set[str]:
+        """Return a set of apps that currently have active locks."""
+        locked_apps = set()
+        for app_name, semaphore in self._app_semaphores.items():
+            if semaphore.locked():
+                locked_apps.add(app_name)
+        return locked_apps

gitops-1.5.0/gitops_server/workers/deployer/worker.py

@@ -0,0 +1,98 @@
+import asyncio
+import logging
+from typing import Any
+
+from opentelemetry import trace
+
+from .deploy import Deployer
+from .semaphore_manager import AppSemaphoreManager
+
+logger = logging.getLogger("gitops_worker")
+
+tracer = trace.get_tracer(__name__)
+
+
+class DeployQueueWorker:
+    """Concurrent deployment worker with per-app serialization.
+
+    Multiple deployments can run simultaneously, but apps are updated
+    sequentially using per-app semaphores. This ensures cluster consistency
+    while allowing parallel deployments of different apps.
+    """
+
+    # Worker singleton
+    _worker: "DeployQueueWorker | None" = None
+
+    @classmethod
+    def get_worker(cls) -> "DeployQueueWorker":
+        if not cls._worker:
+            cls._worker = cls()
+        return cls._worker
+
+    def __init__(self) -> None:
+        self.queue: asyncio.Queue[Any] = asyncio.Queue()
+        self.semaphore_manager = AppSemaphoreManager()
+        self.active_deployments: set[asyncio.Task[None]] = set()
+
+    async def enqueue(self, work: Any) -> None:
+        """Enqueue an item of work for future processing.
+
+        The `work` argument is the body of an incoming GitHub push webhook.
+        """
+        logger.info(f"Enqueued work, {self.queue.qsize() + 1} items in the queue.")
+        await self.queue.put(work)
+
+    async def run(self) -> None:
+        """Run the worker.
+
+        Manages concurrent deployments while maintaining per-app serialization.
+        Each deployment runs as a separate task, allowing multiple deployments
+        to proceed simultaneously.
+        # TODO: Need to gracefully handle termination.
+        """
+        logger.info("Starting up concurrent deployer worker loop")
+        while True:
+            try:
+                # Clean up completed tasks
+                self.active_deployments = {task for task in self.active_deployments if not task.done()}
+
+                # Process new work
+                work = await self.queue.get()
+                deployment_task = asyncio.create_task(self.process_deployment(work))
+                self.active_deployments.add(deployment_task)
+
+                # Log current status
+                locked_apps = self.semaphore_manager.get_locked_apps()
+                logger.info(
+                    f"Active deployments: {len(self.active_deployments)}, " + f"Locked apps: {sorted(locked_apps)}"
+                )
+
+            except Exception as e:
+                logger.error(str(e), exc_info=True)
+
+    async def process_deployment(self, work: Any) -> None:
+        """Process a single deployment in a separate task.
+
+        This allows multiple deployments to run concurrently while
+        maintaining per-app serialization through semaphores.
+        """
+        ref = work.get("ref")
+        logger.info(f'Processing deployment for push to "{ref}".')
+
+        if ref == "refs/heads/master":
+            with tracer.start_as_current_span("gitops_process_webhook") as current_span:
+                try:
+                    deployer = await Deployer.from_push_event(work, self.semaphore_manager)
+                    current_span.set_attribute("gitops.ref", ref)
+                    current_span.set_attribute("gitops.after", work.get("after"))
+                    current_span.set_attribute("gitops.before", work.get("before"))
+                    current_span.set_attribute("gitops.author_email", deployer.author_email)
+                    current_span.set_attribute("gitops.author_name", deployer.author_name)
+                    current_span.set_attribute("gitops.commit_message", deployer.commit_message)
+                    await deployer.deploy()
+
+                except Exception as e:
+                    logger.error(f"Deployment failed: {e}", exc_info=True)
+                    raise
+        else:
+            logger.info(f'Ignoring push to "{ref}" (not master branch).')

{gitops-1.4.0 → gitops-1.5.0}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "gitops"
-version = "1.4.0"
+version = "1.5.0"
 description = "Manage multiple apps across one or more k8s clusters."
 requires-python = ">=3.12"
 readme = "README.md"