djaploy 1.1.7__tar.gz → 1.2.1__tar.gz

{djaploy-1.1.7 → djaploy-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 1.1.7
+Version: 1.2.1
 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.7 → djaploy-1.2.1}/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.7 → djaploy-1.2.1}/djaploy/apps/borg/infra/djaploy_hooks.py

@@ -14,7 +14,6 @@ is not the default, set ``ssh_key`` to the path on the target server
 """
 
 import shlex
-import tempfile
 
 from djaploy.hooks import deploy_hook
 
@@ -44,6 +43,11 @@ def _build_borg_rsh(borg_config) -> str:
     """Build BORG_RSH value from config.
 
     Returns empty string for local repos (no repo_host).
+
+    When ``ssh_known_hosts_file`` is set, uses strict host key checking
+    with that file.  This is recommended for Hetzner Storage Boxes —
+    add the box's fingerprint to a known_hosts file on the target server
+    and point this setting at it.
     """
     repo_host = borg_config.get("repo_host", "")
     if not repo_host:
@@ -51,8 +55,13 @@ def _build_borg_rsh(borg_config) -> str:
 
     repo_port = borg_config.get("repo_port", 22)
     ssh_key = borg_config.get("ssh_key", "")
+    known_hosts = borg_config.get("ssh_known_hosts_file", "")
 
-    rsh = f"ssh -o StrictHostKeyChecking=accept-new -p {repo_port}"
+    if known_hosts:
+        # The file is deployed to ~/.ssh/borg_known_hosts by configure_borg
+        rsh = f"ssh -o StrictHostKeyChecking=yes -o UserKnownHostsFile=~/.ssh/borg_known_hosts -p {repo_port}"
+    else:
+        rsh = f"ssh -o StrictHostKeyChecking=accept-new -p {repo_port}"
     if ssh_key:
         rsh += f" -i {ssh_key}"
     return rsh
@@ -132,7 +141,16 @@ def _generate_backup_script(borg_config, app_user: str, repo_name: str,
     # Fall back to HostConfig.db_dir, then generic default
     host_db_dir = getattr(host_data, 'db_dir', None) if not isinstance(host_data, dict) else host_data.get('db_dir')
     db_path = borg_config.get("db_path") or host_db_dir or f"/home/{app_user}/dbs"
-    media_path = borg_config.get("media_path") or f"/home/{app_user}/apps/{app_name}/media"
+    deployment_strategy = (
+        getattr(host_data, 'deployment_strategy', 'zero_downtime')
+        if not isinstance(host_data, dict)
+        else host_data.get('deployment_strategy', 'zero_downtime')
+    )
+    if deployment_strategy == 'zero_downtime':
+        default_media = f"/home/{app_user}/apps/{app_name}/shared/media"
+    else:
+        default_media = f"/home/{app_user}/apps/{app_name}/media"
+    media_path = borg_config.get("media_path") or default_media
 
     if isinstance(databases, str):
         databases = [databases]
@@ -202,7 +220,8 @@ set -euo pipefail
 export PATH="/usr/local/bin:/usr/bin:/bin:$PATH"
 unset PYTHONPATH
 
-export BORG_PASSPHRASE={shlex.quote(passphrase)}
+# Load passphrase from separate file (deployed with 0600 permissions)
+source /home/{app_user}/.borg_env
 export BORG_REPO={shlex.quote(repo_url)}{rsh_export}{remote_path_export}
 
 LOG_FILE="/home/{app_user}/logs/borg_backup.log"
@@ -267,16 +286,33 @@ log_message "Borg backup completed successfully"
 
 def _deploy_backup_script(borg_config, app_user: str, repo_name: str,
                           host_data):
-    """Deploy borg backup script."""
+    """Deploy borg backup script and passphrase env file."""
     from pyinfra.operations import files
+    from djaploy.utils import temp_files
+
+    # Deploy passphrase in a separate file with restricted permissions
+    passphrase = borg_config.get("passphrase", "")
+    env_path = temp_files.create(suffix='.env')
+    with open(env_path, 'w') as f:
+        f.write(f"export BORG_PASSPHRASE={shlex.quote(passphrase)}\n")
+
+    files.put(
+        name="Deploy borg passphrase env file",
+        src=env_path,
+        dest=f"/home/{app_user}/.borg_env",
+        user=app_user,
+        group=app_user,
+        mode="600",
+        _sudo=True,
+    )
 
     script_content = _generate_backup_script(
         borg_config, app_user, repo_name, host_data
     )
 
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.sh', delete=False) as f:
+    temp_path = temp_files.create(suffix='.sh')
+    with open(temp_path, 'w') as f:
         f.write(script_content)
-        temp_path = f.name
 
     files.put(
         name="Deploy borg backup script",
@@ -363,11 +399,14 @@ def configure_borg(host_data):
         _sudo=True,
     )
 
-    # Deploy SSH keypair for app user if deploy_key is configured
+    # Deploy SSH config for borg backup
     borg_config = getattr(host_data, 'borg_backup', None)
     if borg_config:
+        repo_host = borg_config.get("repo_host", "")
         deploy_key = borg_config.get("deploy_key", None)
-        if deploy_key:
+
+        # Ensure .ssh directory exists when we need SSH access
+        if deploy_key or repo_host:
             files.directory(
                 name="Ensure .ssh directory for app user",
                 path=f"/home/{app_user}/.ssh",
@@ -377,6 +416,7 @@ def configure_borg(host_data):
                 _sudo=True,
             )
 
+        if deploy_key:
             files.put(
                 name="Deploy SSH private key for borg backup",
                 src=str(deploy_key),
@@ -399,6 +439,22 @@ def configure_borg(host_data):
                 _sudo=True,
             )
 
+        # When ssh_known_hosts_file is set, deploy it to the target server
+        # so borg uses strict host key checking against known fingerprints
+        # (e.g. Hetzner's published Storage Box fingerprints).
+        # Without it, _build_borg_rsh falls back to accept-new.
+        known_hosts = borg_config.get("ssh_known_hosts_file", "")
+        if repo_host and known_hosts:
+            files.put(
+                name="Deploy borg SSH known_hosts file",
+                src=str(known_hosts),
+                dest=f"/home/{app_user}/.ssh/borg_known_hosts",
+                user=app_user,
+                group=app_user,
+                mode="644",
+                _sudo=True,
+            )
+
 
 @deploy_hook("deploy:configure")
 def deploy_borg(host_data, artifact_path):
@@ -434,35 +490,73 @@ def restore_borg(host_data, restore_opts):
     if backend and backend != "borg":
         return
 
-    from pyinfra.operations import server, systemd
+    from pyinfra.operations import files, server, systemd
 
     app_user = getattr(host_data, "app_user", None) or "app"
-    borg_config = getattr(host_data, "borg_backup", None)
+
+    # Use source borg config for cross-env restores (e.g. --env prod --target staging),
+    # fall back to the target host's own borg config for same-env restores.
+    source_borg_config = restore_opts.get("source_borg_config")
+    target_borg_config = getattr(host_data, "borg_backup", None)
+    borg_config = source_borg_config or target_borg_config
     if not borg_config:
         return
 
-    passphrase = borg_config.get("passphrase", "")
-    repo_name = getattr(host_data, 'name', 'unknown-host').replace(" ", "_").lower()
+    source_repo_name = restore_opts.get("source_repo_name", "")
+    if source_borg_config and not source_repo_name:
+        raise ValueError(
+            "source_repo_name is required when source_borg_config is provided"
+        )
+    repo_name = (
+        source_repo_name
+        or getattr(host_data, 'name', 'unknown-host').replace(" ", "_").lower()
+    )
 
+    # Restore paths come from the *target* host (where files will be written)
     app_name = getattr(host_data, 'app_name', '') if not isinstance(host_data, dict) else host_data.get('app_name', '')
     # Fall back to HostConfig.db_dir, then generic default
     host_db_dir = getattr(host_data, 'db_dir', None) if not isinstance(host_data, dict) else host_data.get('db_dir')
+    target_bc = target_borg_config or {}
     db_path = (
-        borg_config.get("db_path") if isinstance(borg_config, dict)
-        else getattr(borg_config, "db_path", None)
+        target_bc.get("db_path") if isinstance(target_bc, dict)
+        else getattr(target_bc, "db_path", None)
     ) or host_db_dir or f"/home/{app_user}/dbs"
 
+    deployment_strategy = (
+        getattr(host_data, 'deployment_strategy', 'zero_downtime')
+        if not isinstance(host_data, dict)
+        else host_data.get('deployment_strategy', 'zero_downtime')
+    )
+    if deployment_strategy == 'zero_downtime':
+        default_media = f"/home/{app_user}/apps/{app_name}/shared/media"
+    else:
+        default_media = f"/home/{app_user}/apps/{app_name}/media"
     media_path = (
-        borg_config.get("media_path") if isinstance(borg_config, dict)
-        else getattr(borg_config, "media_path", None)
-    ) or f"/home/{app_user}/apps/{app_name}/media"
+        target_bc.get("media_path") if isinstance(target_bc, dict)
+        else getattr(target_bc, "media_path", None)
+    ) or default_media
 
     archive = restore_opts.get("archive", "latest")
     db_only = restore_opts.get("db_only", False)
     services = getattr(host_data, "services", None) or []
 
+    # Repo connection details come from the *source* borg config, but
+    # ssh_known_hosts_file must come from the *target* (the file lives on
+    # the machine running borg, not the machine the backup was taken from).
     repo_url = _build_repo_url(borg_config, repo_name)
-    borg_rsh = _build_borg_rsh(borg_config)
+    if source_borg_config:
+        rsh_config = dict(borg_config)
+        # ssh_key and ssh_known_hosts_file refer to files on the machine
+        # running borg — use the *target* host's values, not the source's.
+        for _key in ("ssh_key", "ssh_known_hosts_file"):
+            rsh_config[_key] = (
+                target_bc.get(_key, "")
+                if isinstance(target_bc, dict)
+                else getattr(target_bc, _key, "")
+            )
+    else:
+        rsh_config = borg_config
+    borg_rsh = _build_borg_rsh(rsh_config)
     rsh_export = f'\nexport BORG_RSH={shlex.quote(borg_rsh)}' if borg_rsh else ''
     remote_path = borg_config.get("remote_path", None)
     remote_path_export = f'\nexport BORG_REMOTE_PATH={shlex.quote(remote_path)}' if remote_path else ''
@@ -484,29 +578,61 @@ def restore_borg(host_data, restore_opts):
         )
 
     # Build restore script
+    #
+    # For cross-env restores the media sits under the *source* host's path
+    # inside the archive, but must be copied to the *target* host's path.
+    source_media_path = restore_opts.get("source_media_path", "")
+    archive_media_path = source_media_path or media_path
+
     media_restore = ""
     if not db_only:
         media_restore = f'''
 # Restore media
-if [ -d "$TEMP_DIR{media_path}" ]; then
-    log_message "Restoring media to {media_path}"
+if [ -d "$TEMP_DIR{archive_media_path}" ]; then
+    log_message "Restoring media from $TEMP_DIR{archive_media_path} to {media_path}"
     mkdir -p "{media_path}"
-    cp -a "$TEMP_DIR{media_path}/." "{media_path}/"
+    cp -a "$TEMP_DIR{archive_media_path}/." "{media_path}/"
     log_message "Media restore complete"
 else
-    log_message "No media found in archive, skipping"
+    log_message "No media found in archive at {archive_media_path}, skipping"
 fi
 '''
 
+    # For cross-env restores, upload a temporary env file with the source
+    # passphrase (0600) instead of inlining it in the script.
+    if source_borg_config:
+        import os as _os
+        passphrase = _os.environ.get("DJAPLOY_SOURCE_BORG_PASSPHRASE", "")
+        restore_env_path = f"/home/{app_user}/.borg_restore_env"
+
+        from djaploy.utils import temp_files as _temp_files
+        _env_tmp = _temp_files.create(suffix='.env')
+        with open(_env_tmp, 'w') as _f:
+            _f.write(f"export BORG_PASSPHRASE={shlex.quote(passphrase)}\n")
+
+        files.put(
+            name="Deploy source borg passphrase for restore",
+            src=_env_tmp,
+            dest=restore_env_path,
+            user=app_user,
+            group=app_user,
+            mode="600",
+            _sudo=True,
+        )
+        passphrase_line = f'source {restore_env_path}'
+    else:
+        restore_env_path = None
+        passphrase_line = f'source /home/{app_user}/.borg_env'
+
     restore_script = f'''set -euo pipefail
 unset PYTHONPATH
-export BORG_PASSPHRASE={shlex.quote(passphrase)}{rsh_export}{remote_path_export}
+{passphrase_line}{rsh_export}{remote_path_export}
 
 REPO={shlex.quote(repo_url)}
 TEMP_DIR="/home/{app_user}/tmp/borg_restore_$$"
 
 log_message() {{ echo "[$(date +"%Y-%m-%d %H:%M:%S")] $1"; }}
-cleanup() {{ rm -rf "$TEMP_DIR"; }}
+cleanup() {{ rm -rf "$TEMP_DIR"; {f'rm -f {shlex.quote(restore_env_path)};' if restore_env_path else ''} }}
 trap cleanup EXIT
 
 ARCHIVE_NAME={archive_ref}
@@ -544,11 +670,12 @@ log_message "Borg restore complete"
     # Deploy restore script as temp file and execute it
     restore_script_path = f"/home/{app_user}/tmp/borg_restore.sh"
 
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.sh', delete=False) as f:
+    from djaploy.utils import temp_files
+
+    temp_path = temp_files.create(suffix='.sh')
+    with open(temp_path, 'w') as f:
         f.write(f"#!/bin/bash\n{restore_script}")
-        temp_path = f.name
 
-    from pyinfra.operations import files
     files.directory(
         name="Ensure tmp directory for borg restore",
         path=f"/home/{app_user}/tmp",
@@ -575,9 +702,13 @@ log_message "Borg restore complete"
         _use_sudo_login=True,
     )
 
+    cleanup_commands = [f"rm -f {restore_script_path}"]
+    if restore_env_path:
+        cleanup_commands.append(f"rm -f {restore_env_path}")
+
     server.shell(
         name="Clean up borg restore script",
-        commands=[f"rm -f {restore_script_path}"],
+        commands=cleanup_commands,
         _sudo=True,
         _sudo_user=app_user,
     )

{djaploy-1.1.7 → djaploy-1.2.1}/djaploy/apps/janitor/infra/djaploy_hooks.py

@@ -9,7 +9,6 @@ to bootstrap the deploy user that all subsequent commands use.
 import importlib.util
 import os
 import sys
-import tempfile
 
 from djaploy.hooks import deploy_hook, hook
 
@@ -23,21 +22,24 @@ def override_inventory_to_root(context):
     """
     inventory_file = context["inventory_file"]
 
-    spec = importlib.util.spec_from_file_location("_janitor_inv", inventory_file)
+    module_name = f"_janitor_inv_{id(inventory_file)}"
+    spec = importlib.util.spec_from_file_location(module_name, inventory_file)
     module = importlib.util.module_from_spec(spec)
 
     try:
-        sys.modules["_janitor_inv"] = module
+        sys.modules[module_name] = module
         spec.loader.exec_module(module)
         hosts = getattr(module, "hosts", [])
     finally:
-        sys.modules.pop("_janitor_inv", None)
+        sys.modules.pop(module_name, None)
 
     # Write a temp inventory with ssh_user forced to root
     from djaploy.deploy import _make_value_serializable
 
-    fd, tmp_path = tempfile.mkstemp(suffix=".py", prefix="janitor_inv_")
-    with os.fdopen(fd, "w") as f:
+    from djaploy.utils import temp_files
+
+    tmp_path = temp_files.create(suffix=".py", prefix="janitor_inv_")
+    with open(tmp_path, "w") as f:
         f.write("# Auto-generated inventory (ssh_user overridden to root)\n\n")
         f.write("hosts = [\n")
         for host_entry in hosts:

{djaploy-1.1.7 → djaploy-1.2.1}/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",
@@ -66,18 +67,31 @@ def deploy_nginx(host_data, artifact_path):
                 _sudo=True,
             )
 
-    # Symlink each site individually to avoid creating a literal '*' symlink
-    # when sites-available is empty, and to avoid enabling unrelated sites
-    # on multi-tenant servers.
-    server.shell(
-        name="Enable NGINX sites",
-        commands=[
-            "for f in /etc/nginx/sites-available/*; do "
-            "[ -f \"$f\" ] && ln -fs \"$f\" /etc/nginx/sites-enabled/; "
-            "done",
-        ],
-        _sudo=True,
-    )
+    # Only enable the site for this app — avoid enabling unrelated sites
+    # on multi-tenant servers. Skip if the config file doesn't exist
+    # (e.g. when nginx_conf={"custom": True} and a custom hook handles it).
+    app_name = getattr(host_data, 'app_name', None)
+    if app_name:
+        server.shell(
+            name=f"Enable {app_name} NGINX site",
+            commands=[
+                f"test -f /etc/nginx/sites-available/{app_name} && "
+                f"ln -fs /etc/nginx/sites-available/{app_name} /etc/nginx/sites-enabled/{app_name} || true",
+            ],
+            _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")