djaploy 1.1.8__tar.gz → 1.2.2__tar.gz

{djaploy-1.1.8 → djaploy-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 1.1.8
+Version: 1.2.2
 Summary: Modular Django deployment system based on pyinfra
 Author-email: Johanna Mae Dimayuga <johanna@techco.fi>
 License: MIT License
@@ -236,6 +236,107 @@ Deployment flow:
 7. Collects static files
 8. Restarts services
 
+## Deployment Strategies
+
+djaploy supports three deployment strategies, configured via `deployment_strategy` on `HostConfig`.
+
+### In-place (`"in_place"`)
+
+The simplest strategy. Code is extracted directly into the app directory and services are restarted. Has brief downtime during restart.
+
+### Zero-downtime (`"zero_downtime"`)
+
+Uses a `releases/` directory with a `current` symlink. Each deploy creates a new immutable release, swaps the symlink atomically, and sends USR2 via gunicornherder to reload gunicorn. No downtime, but no pre-activation testing.
+
+### Blue-green (`"bluegreen"`)
+
+Two independent slots (blue and green), each running its own gunicorn process on a separate Unix socket. Traffic switching happens via nginx reload. Supports staging a release for testing before switching.
+
+```python
+HostConfig(
+    "my-server",
+    ssh_hostname="192.168.1.100",
+    app_name="myapp",
+    app_user="myapp-api",
+    deployment_strategy="bluegreen",
+    # ...
+)
+```
+
+#### Blue-green commands
+
+```bash
+# Deploy to inactive slot (does NOT switch traffic)
+python manage.py djaploy deploy --env production --latest
+
+# Activate: switch nginx to the staged slot (zero downtime)
+python manage.py djaploy activate --env production
+
+# Deploy + activate in one step
+python manage.py djaploy deploy --env production --latest --activate
+
+# Show both slots with release info, paths, service status
+python manage.py djaploy status --env production
+
+# Rollback: switch back to previous slot (instant)
+python manage.py djaploy rollback --env production
+```
+
+#### Blue-green deployment flow
+
+1. **Deploy** -- extracts artifact to inactive slot, installs dependencies, runs migrations, starts the slot's gunicorn service
+2. **Test** -- the staged slot is running and reachable via its socket (e.g. `curl --unix-socket /run/myapp-green/myapp.sock http://localhost/health/`)
+3. **Activate** -- rewrites nginx upstream to point to the new slot, reloads nginx
+4. **Rollback** (if needed) -- switches nginx back to the previous slot, which is still running
+
+### Server directory layout comparison
+
+For `app_user="myapp-api"`, `app_name="myapp"`:
+
+| Path | `in_place` | `zero_downtime` | `bluegreen` |
+|------|-----------|-----------------|-------------|
+| App code | `.../apps/myapp/` | `.../apps/myapp/current/` | `.../apps/myapp/slots/{blue\|green}/` |
+| Virtualenv | Managed by Poetry | `.../shared/venv-{HASH}-py{ver}/` | `.../shared/venv-{HASH}-py{ver}/` |
+| Static files | `.../apps/myapp/staticfiles/` | `.../apps/myapp/shared/staticfiles/` | `.../apps/myapp/shared/staticfiles/` |
+| Media files | `.../apps/myapp/media/` | `.../apps/myapp/shared/media/` | `.../apps/myapp/shared/media/` |
+| Database | via `db_dir` | via `db_dir` | via `db_dir` |
+
+All paths are relative to `/home/{app_user}/`.
+
+#### Shared directory (`zero_downtime` and `bluegreen`)
+
+Both strategies use a `shared/` directory for resources that persist across deployments:
+
+| Content | Purpose |
+|---------|---------|
+| `venv-{HASH}-py{version}/` | Virtualenvs keyed by `poetry.lock` hash. Reused when dependencies haven't changed. |
+| `staticfiles/` | Output of `collectstatic`. Served by nginx. |
+| `media/` | User-uploaded files. Served by nginx. |
+| Custom paths via `shared_resources` | Project-specific shared directories (e.g. `bostad/public`). |
+
+#### Systemd services comparison
+
+| Strategy | Service name | Socket path | Process |
+|----------|-------------|-------------|---------|
+| `in_place` | `{app}.service` | `/run/{app}/{app}.sock` | `poetry run gunicorn` |
+| `zero_downtime` | `{app}.service` | `/run/{app}/{app}.sock` | gunicornherder wrapping gunicorn |
+| `bluegreen` | `{app}-blue.service`, `{app}-green.service` | `/run/{app}-blue/{app}.sock`, `/run/{app}-green/{app}.sock` | Plain gunicorn (`Type=notify`) |
+
+Blue-green uses `Type=notify` -- gunicorn has native systemd-notify support, so systemd knows when the process is ready without needing gunicornherder.
+
+#### Nginx configuration (bluegreen)
+
+Blue-green deploys the nginx upstream as a separate include file so it can be rewritten during activation without touching the site config:
+
+- Site config: `/etc/nginx/sites-available/{app_name}` (no inline upstream block)
+- Upstream config: `/etc/nginx/sites-available/{app_name}-upstream.conf`
+
+Activation rewrites the upstream file to point to the new slot's socket and reloads nginx.
+
+#### State tracking (bluegreen)
+
+Blue-green maintains a `state.json` file at `/home/{app_user}/apps/{app_name}/state.json` that tracks the active slot and deployment metadata (release name, commit, venv path, python interpreter) for each slot. This is printed during deploy, activate, and status commands.
+
 ### Certificate management
 
 ```bash

{djaploy-1.1.8 → djaploy-1.2.2}/README.md

@@ -174,6 +174,107 @@ Deployment flow:
 7. Collects static files
 8. Restarts services
 
+## Deployment Strategies
+
+djaploy supports three deployment strategies, configured via `deployment_strategy` on `HostConfig`.
+
+### In-place (`"in_place"`)
+
+The simplest strategy. Code is extracted directly into the app directory and services are restarted. Has brief downtime during restart.
+
+### Zero-downtime (`"zero_downtime"`)
+
+Uses a `releases/` directory with a `current` symlink. Each deploy creates a new immutable release, swaps the symlink atomically, and sends USR2 via gunicornherder to reload gunicorn. No downtime, but no pre-activation testing.
+
+### Blue-green (`"bluegreen"`)
+
+Two independent slots (blue and green), each running its own gunicorn process on a separate Unix socket. Traffic switching happens via nginx reload. Supports staging a release for testing before switching.
+
+```python
+HostConfig(
+    "my-server",
+    ssh_hostname="192.168.1.100",
+    app_name="myapp",
+    app_user="myapp-api",
+    deployment_strategy="bluegreen",
+    # ...
+)
+```
+
+#### Blue-green commands
+
+```bash
+# Deploy to inactive slot (does NOT switch traffic)
+python manage.py djaploy deploy --env production --latest
+
+# Activate: switch nginx to the staged slot (zero downtime)
+python manage.py djaploy activate --env production
+
+# Deploy + activate in one step
+python manage.py djaploy deploy --env production --latest --activate
+
+# Show both slots with release info, paths, service status
+python manage.py djaploy status --env production
+
+# Rollback: switch back to previous slot (instant)
+python manage.py djaploy rollback --env production
+```
+
+#### Blue-green deployment flow
+
+1. **Deploy** -- extracts artifact to inactive slot, installs dependencies, runs migrations, starts the slot's gunicorn service
+2. **Test** -- the staged slot is running and reachable via its socket (e.g. `curl --unix-socket /run/myapp-green/myapp.sock http://localhost/health/`)
+3. **Activate** -- rewrites nginx upstream to point to the new slot, reloads nginx
+4. **Rollback** (if needed) -- switches nginx back to the previous slot, which is still running
+
+### Server directory layout comparison
+
+For `app_user="myapp-api"`, `app_name="myapp"`:
+
+| Path | `in_place` | `zero_downtime` | `bluegreen` |
+|------|-----------|-----------------|-------------|
+| App code | `.../apps/myapp/` | `.../apps/myapp/current/` | `.../apps/myapp/slots/{blue\|green}/` |
+| Virtualenv | Managed by Poetry | `.../shared/venv-{HASH}-py{ver}/` | `.../shared/venv-{HASH}-py{ver}/` |
+| Static files | `.../apps/myapp/staticfiles/` | `.../apps/myapp/shared/staticfiles/` | `.../apps/myapp/shared/staticfiles/` |
+| Media files | `.../apps/myapp/media/` | `.../apps/myapp/shared/media/` | `.../apps/myapp/shared/media/` |
+| Database | via `db_dir` | via `db_dir` | via `db_dir` |
+
+All paths are relative to `/home/{app_user}/`.
+
+#### Shared directory (`zero_downtime` and `bluegreen`)
+
+Both strategies use a `shared/` directory for resources that persist across deployments:
+
+| Content | Purpose |
+|---------|---------|
+| `venv-{HASH}-py{version}/` | Virtualenvs keyed by `poetry.lock` hash. Reused when dependencies haven't changed. |
+| `staticfiles/` | Output of `collectstatic`. Served by nginx. |
+| `media/` | User-uploaded files. Served by nginx. |
+| Custom paths via `shared_resources` | Project-specific shared directories (e.g. `bostad/public`). |
+
+#### Systemd services comparison
+
+| Strategy | Service name | Socket path | Process |
+|----------|-------------|-------------|---------|
+| `in_place` | `{app}.service` | `/run/{app}/{app}.sock` | `poetry run gunicorn` |
+| `zero_downtime` | `{app}.service` | `/run/{app}/{app}.sock` | gunicornherder wrapping gunicorn |
+| `bluegreen` | `{app}-blue.service`, `{app}-green.service` | `/run/{app}-blue/{app}.sock`, `/run/{app}-green/{app}.sock` | Plain gunicorn (`Type=notify`) |
+
+Blue-green uses `Type=notify` -- gunicorn has native systemd-notify support, so systemd knows when the process is ready without needing gunicornherder.
+
+#### Nginx configuration (bluegreen)
+
+Blue-green deploys the nginx upstream as a separate include file so it can be rewritten during activation without touching the site config:
+
+- Site config: `/etc/nginx/sites-available/{app_name}` (no inline upstream block)
+- Upstream config: `/etc/nginx/sites-available/{app_name}-upstream.conf`
+
+Activation rewrites the upstream file to point to the new slot's socket and reloads nginx.
+
+#### State tracking (bluegreen)
+
+Blue-green maintains a `state.json` file at `/home/{app_user}/apps/{app_name}/state.json` that tracks the active slot and deployment metadata (release name, commit, venv path, python interpreter) for each slot. This is printed during deploy, activate, and status commands.
+
 ### Certificate management
 
 ```bash

{djaploy-1.1.8 → djaploy-1.2.2}/djaploy/apps/nginx/infra/djaploy_hooks.py

@@ -34,6 +34,7 @@ def configure_nginx(host_data):
 def deploy_nginx(host_data, artifact_path):
     """Deploy NGINX configuration files and SSL certificates."""
     from pyinfra.operations import server, files
+    from djaploy.infra.utils import is_bluegreen
 
     server.shell(
         name="Clear default NGINX sites",
@@ -80,6 +81,18 @@ def deploy_nginx(host_data, artifact_path):
             _sudo=True,
         )
 
+        # For bluegreen, also enable the upstream config
+        if is_bluegreen(host_data):
+            server.shell(
+                name=f"Enable {app_name} NGINX upstream config",
+                commands=[
+                    f"test -f /etc/nginx/sites-available/{app_name}-upstream.conf && "
+                    f"ln -fs /etc/nginx/sites-available/{app_name}-upstream.conf "
+                    f"/etc/nginx/sites-enabled/{app_name}-upstream.conf || true",
+                ],
+                _sudo=True,
+            )
+
 
 @deploy_hook("deploy:start")
 def reload_nginx(host_data, artifact_path):

{djaploy-1.1.8 → djaploy-1.2.2}/djaploy/apps/systemd/infra/djaploy_hooks.py

@@ -21,13 +21,33 @@ def reload_systemd_daemon(host_data, artifact_path):
 @deploy_hook("deploy:start")
 def start_services(host_data, artifact_path):
     """Start or restart application services after deploy."""
+    from pyinfra import host
     from pyinfra.operations import systemd
 
-    from djaploy.infra.utils import is_zero_downtime
-    zero_downtime = is_zero_downtime(host_data)
+    from djaploy.infra.utils import is_zero_downtime, is_bluegreen, get_slot_service_name
+
+    if is_bluegreen(host_data):
+        # Start/restart only the target slot's service.
+        # The other slot may be empty (first deploy) so we must NOT
+        # try to start it — only enable the target slot's service.
+        target_slot = getattr(host.data, '_bluegreen_target_slot', None)
+        if not target_slot:
+            return
+
+        for service in getattr(host_data, "services", []):
+            app_name = getattr(host_data, 'app_name', service)
+            slot_service = get_slot_service_name(app_name, target_slot)
 
-    for service in getattr(host_data, "services", []):
-        if zero_downtime:
+            systemd.service(
+                name=f"Start and restart {slot_service} (target slot)",
+                service=slot_service,
+                running=True,
+                enabled=True,
+                restarted=True,
+                _sudo=True,
+            )
+    elif is_zero_downtime(host_data):
+        for service in getattr(host_data, "services", []):
             systemd.service(
                 name=f"Start and enable {service}",
                 service=service,
@@ -41,7 +61,8 @@ def start_services(host_data, artifact_path):
                 reloaded=True,
                 _sudo=True,
             )
-        else:
+    else:
+        for service in getattr(host_data, "services", []):
             systemd.service(
                 name=f"Restart and enable {service}",
                 service=service,
@@ -65,19 +86,23 @@ def start_services(host_data, artifact_path):
 def reload_services_on_rollback(host_data, release):
     """Reload or restart services after a rollback."""
     from pyinfra.operations import systemd
-    from djaploy.infra.utils import is_zero_downtime
-
-    zero_downtime = is_zero_downtime(host_data)
+    from djaploy.infra.utils import is_zero_downtime, is_bluegreen
 
-    for service in getattr(host_data, "services", []):
-        if zero_downtime:
+    if is_bluegreen(host_data):
+        # For bluegreen rollback, nginx switching is handled by the core
+        # rollback hook. We just need to ensure the target slot's service
+        # is running (it should already be from the previous deploy).
+        pass
+    elif is_zero_downtime(host_data):
+        for service in getattr(host_data, "services", []):
             systemd.service(
                 name=f"Reload {service} after rollback",
                 service=service,
                 reloaded=True,
                 _sudo=True,
             )
-        else:
+    else:
+        for service in getattr(host_data, "services", []):
             systemd.service(
                 name=f"Restart {service} after rollback",
                 service=service,

{djaploy-1.1.8 → djaploy-1.2.2}/djaploy/builtin_hooks.py

@@ -103,6 +103,19 @@ def _deploy_calculate_release_info(context):
     if release_info:
         context["pyinfra_data"]["version"] = release_info["new_version"]
         context["pyinfra_data"]["commit"] = release_info["commit"]
+    elif "commit" not in context["pyinfra_data"]:
+        # Always pass commit hash even without versioning configured
+        try:
+            import subprocess
+            from django.conf import settings
+            commit = subprocess.check_output(
+                ["git", "rev-parse", "--short", "HEAD"],
+                cwd=str(settings.GIT_DIR),
+                text=True,
+            ).strip()
+            context["pyinfra_data"]["commit"] = commit
+        except Exception:
+            pass
 
 
 # ── deploy:postcommand ───────────────────────────────────────────────
@@ -150,7 +163,7 @@ def _rollback_validate_strategy(context):
     _, data = hosts[0]
     strategy = (data.get("deployment_strategy") if isinstance(data, dict)
                 else getattr(data, "deployment_strategy", "zero_downtime"))
-    if strategy != "zero_downtime":
+    if strategy not in ("zero_downtime", "bluegreen"):
         raise ValueError(
-            "Rollback is only supported with deployment_strategy='zero_downtime'"
+            "Rollback is only supported with deployment_strategy='zero_downtime' or 'bluegreen'"
         )

djaploy-1.2.2/djaploy/commands/activate.py

@@ -0,0 +1,26 @@
+"""
+Pyinfra command: activate a blue-green deployment slot.
+
+Discovers and runs all @deploy_hook functions for the activate phase:
+
+    activate:pre  — verify target slot is healthy
+    activate      — switch nginx upstream, update state
+    activate:post — cleanup tasks
+
+Usage (via djaploy management command):
+    manage.py djaploy activate --env production
+"""
+
+from pyinfra import host
+from pyinfra.api import deploy as _deploy_decorator
+
+from djaploy.hooks import discover_hooks, get_registry
+
+discover_hooks()
+registry = get_registry()
+
+for phase in ("activate:pre", "activate", "activate:post"):
+    for hook in registry.get_remote_hooks(phase):
+        _deploy_decorator(hook.function.__name__)(hook.function)(
+            host.data
+        )

{djaploy-1.1.8 → djaploy-1.2.2}/djaploy/commands/deploy.py

@@ -29,3 +29,12 @@ for phase in ("deploy:upload", "deploy:configure", "deploy:pre", "deploy:start")
         _deploy_decorator(hook.function.__name__)(hook.function)(
             host.data, artifact_path
         )
+
+# If --activate flag is set, run activation phases after deploy
+_activate_val = getattr(host.data, "activate", None)
+if _activate_val in (True, "true", "True"):
+    for phase in ("activate:pre", "activate", "activate:post"):
+        for hook in registry.get_remote_hooks(phase):
+            _deploy_decorator(hook.function.__name__)(hook.function)(
+                host.data
+            )

djaploy-1.2.2/djaploy/commands/status.py

@@ -0,0 +1,88 @@
+"""
+Pyinfra command: show blue-green deployment status.
+
+Reads and displays the blue-green state from each host.
+
+Usage (via djaploy management command):
+    manage.py djaploy status --env production
+"""
+
+from pyinfra import host
+from pyinfra.api import deploy as _deploy_decorator
+from pyinfra.operations import python as python_op
+
+from djaploy.hooks import discover_hooks, get_registry
+from djaploy.infra.utils import is_bluegreen, get_app_path, get_slot_socket_path
+from djaploy.infra.djaploy_hooks import _read_slot_info_from_remote
+
+discover_hooks()
+registry = get_registry()
+
+if is_bluegreen(host.data):
+    app_name = getattr(host.data, 'app_name', 'unknown')
+    app_path = get_app_path(host.data)
+    state_file = f"{app_path}/state.json"
+
+    def _show_status(app_n, state_f):
+        blue_info = _read_slot_info_from_remote(host, "blue", state_f)
+        green_info = _read_slot_info_from_remote(host, "green", state_f)
+
+        # Read active slot
+        import json
+        result = host.run_shell_command(command=f"cat {state_f}")
+        active = "none"
+        if result[0] and len(result) > 1:
+            try:
+                lines = [l.line if hasattr(l, 'line') else str(l) for l in result[1]]
+                state_data = json.loads("\n".join(lines))
+                active = state_data.get("active_slot") or "none"
+            except (json.JSONDecodeError, KeyError):
+                pass
+
+        print(f"\nBlue-Green Status for {app_n}")
+        print("=" * 40)
+        print(f"Active slot: {active}\n")
+
+        for slot, info in [("blue", blue_info), ("green", green_info)]:
+            tag = "ACTIVE" if active == slot else "inactive"
+            print(f"{slot.upper()} ({tag}):")
+            if info:
+                print(f"  Release:     {info.get('release', 'unknown')}")
+                print(f"  Commit:      {info.get('commit', 'unknown')}")
+                print(f"  Deployed at: {info.get('deployed_at', 'unknown')}")
+                print(f"  Python:      {info.get('python_interpreter', 'unknown')}")
+                print(f"  Venv:        {info.get('venv_path', 'unknown')}")
+                print(f"  Socket:      {get_slot_socket_path(app_n, slot)}")
+            else:
+                print("  (empty)")
+            print()
+
+        # Show service status
+        for slot in ("blue", "green"):
+            svc = f"{app_n}-{slot}.service"
+            res = host.run_shell_command(command=f"systemctl is-active {svc} 2>/dev/null || echo inactive")
+            status_str = "unknown"
+            if res[0] and len(res) > 1:
+                try:
+                    status_str = (list(res[1])[0].line if hasattr(list(res[1])[0], 'line') else str(list(res[1])[0])).strip()
+                except (IndexError, AttributeError):
+                    pass
+            print(f"Service {svc}: {status_str}")
+        print()
+
+    python_op.call(
+        name="Show blue-green status",
+        function=_show_status,
+        app_n=app_name,
+        state_f=state_file,
+    )
+else:
+    def _show_non_bluegreen():
+        strategy = getattr(host.data, "deployment_strategy", "zero_downtime")
+        print(f"\nDeployment strategy: {strategy}")
+        print("Not a blue-green deployment. Use deploy/rollback commands.\n")
+
+    python_op.call(
+        name="Show deployment status",
+        function=_show_non_bluegreen,
+    )

{djaploy-1.1.8 → djaploy-1.2.2}/djaploy/config.py

@@ -213,10 +213,10 @@ class HostConfig(tuple, metaclass=HostConfigMetaclass):
 
         # Validate deployment_strategy
         strategy = config.get("deployment_strategy", "zero_downtime")
-        if strategy not in ("in_place", "zero_downtime"):
+        if strategy not in ("in_place", "zero_downtime", "bluegreen"):
             raise ValueError(
                 f"Invalid deployment_strategy: {strategy!r}. "
-                f"Must be 'in_place' or 'zero_downtime'"
+                f"Must be 'in_place', 'zero_downtime', or 'bluegreen'"
             )
 
         # Expand SSH key path if provided

{djaploy-1.1.8 → djaploy-1.2.2}/djaploy/deploy.py

@@ -222,6 +222,30 @@ def rollback_project(inventory_file: str,
     })
 
 
+def activate_project(inventory_file: str, **kwargs):
+    """Activate the staged blue-green slot."""
+    env_name = Path(inventory_file).stem
+    run_command({
+        "command": "activate",
+        "env": env_name,
+        "command_file": str(_get_command_file("activate")),
+        "inventory_file": inventory_file,
+        "pyinfra_data": _build_pyinfra_data(env_name),
+    })
+
+
+def bluegreen_status(inventory_file: str, **kwargs):
+    """Show blue-green deployment status."""
+    env_name = Path(inventory_file).stem
+    run_command({
+        "command": "status",
+        "env": env_name,
+        "command_file": str(_get_command_file("status")),
+        "inventory_file": inventory_file,
+        "pyinfra_data": _build_pyinfra_data(env_name),
+    })
+
+
 # ------------------------------------------------------------------
 # Internal helpers (called by hooks in builtin_hooks.py)
 # ------------------------------------------------------------------