djaploy 1.2.6__tar.gz → 1.2.7__tar.gz

{djaploy-1.2.6 → djaploy-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 1.2.6
+Version: 1.2.7
 Summary: Modular Django deployment system based on pyinfra
 Author-email: Johanna Mae Dimayuga <johanna@techco.fi>
 License: MIT License

{djaploy-1.2.6 → djaploy-1.2.7}/djaploy/apps/systemd/infra/djaploy_hooks.py

@@ -34,15 +34,20 @@ def start_services(host_data, artifact_path):
         if not target_slot:
             return
 
+        from pyinfra.operations import server
         for service in getattr(host_data, "services", []):
             slot_service = get_slot_service_name(service, target_slot)
 
-            systemd.service(
-                name=f"Start and restart {slot_service} (target slot)",
-                service=slot_service,
-                running=True,
-                enabled=True,
-                restarted=True,
+            # Only start if the service unit file exists — custom services
+            # (e.g. streaming) may be rendered by project hooks, not djaploy core.
+            server.shell(
+                name=f"Start {slot_service} if unit exists",
+                commands=[
+                    f"test -f /etc/systemd/system/{slot_service}.service && "
+                    f"systemctl enable {slot_service} && "
+                    f"systemctl restart {slot_service} || "
+                    f"echo 'Unit {slot_service}.service not found, skipping'",
+                ],
                 _sudo=True,
             )
 

{djaploy-1.2.6 → djaploy-1.2.7}/djaploy/infra/djaploy_hooks.py

@@ -648,8 +648,13 @@ def activate_release(host_data, artifact_path):
         run_migrations(app_user, build_path, host_data)
         collect_static(app_user, build_path, host_data)
 
-        # Update state.json on the remote server
+        # Update state.json on the remote server.
+        # Serialize release_name and commit with json.dumps to safely
+        # handle quotes and special characters in branch names / messages.
+        import json as _json
         commit = getattr(host_data, 'commit', 'unknown')
+        safe_release = _json.dumps(release_name)
+        safe_commit = _json.dumps(commit)
         socket_path = get_slot_socket_path(app_name, target_slot)
         server.shell(
             name="Update state.json with deployment info",
@@ -660,8 +665,8 @@ def activate_release(host_data, artifact_path):
                 f"python_path = venv_path + '/bin/python' if venv_path != 'unknown' else 'unknown'\n"
                 f"s = json.load(open('{state_file}'))\n"
                 f"s['slots']['{target_slot}'] = {{\n"
-                f"    'release': '{release_name}',\n"
-                f"    'commit': '{commit}',\n"
+                f"    'release': {safe_release},\n"
+                f"    'commit': {safe_commit},\n"
                 f"    'deployed_at': datetime.datetime.now(datetime.timezone.utc).isoformat(),\n"
                 f"    'python_interpreter': python_path,\n"
                 f"    'venv_path': venv_path,\n"
@@ -835,6 +840,7 @@ def activate_bluegreen(host_data):
     from pyinfra.facts.server import Command
     from djaploy.infra.utils import (
         is_bluegreen, get_app_path, get_slot_socket_path,
+        get_slot_service_name,
     )
     from djaploy.infra.bluegreen import (
         read_active_slot_cmd, set_active_slot_cmd, other_slot,
@@ -887,6 +893,44 @@ def activate_bluegreen(host_data):
     # Store on host.data so activate:post hooks can read it
     host.data._bluegreen_activated_slot = target_slot
 
+    # Health check: verify all target slot services are running before
+    # switching nginx. Abort activation if any service is down.
+    services = getattr(host_data, "services", []) or []
+    failed_checks = []
+    for svc in services:
+        slot_svc = get_slot_service_name(svc, target_slot)
+        server.shell(
+            name=f"Health check: verify {slot_svc} is active",
+            commands=[
+                f"if systemctl is-active {slot_svc}.service > /dev/null 2>&1; then "
+                f"echo 'Health check passed: {slot_svc} is active'; "
+                f"else "
+                f"echo 'ACTIVATION ABORTED: {slot_svc} is not running.' && "
+                f"echo 'Check: systemctl status {slot_svc}.service' && "
+                f"exit 1; "
+                f"fi",
+            ],
+            _sudo=True,
+        )
+
+    # Extra gunicorn-specific check: verify the socket is responding
+    socket_path = get_slot_socket_path(app_name, target_slot)
+    server.shell(
+        name=f"Health check: verify {target_slot} gunicorn socket responds",
+        commands=[
+            f"if curl -sf --max-time 5 --unix-socket {socket_path} http://localhost/ > /dev/null 2>&1; then "
+            f"echo 'Health check passed: gunicorn socket is responding'; "
+            f"elif [ -S {socket_path} ]; then "
+            f"echo 'Health check: socket exists, HTTP may be non-200 (proceeding)'; "
+            f"else "
+            f"echo 'ACTIVATION ABORTED: gunicorn socket not responding.' && "
+            f"echo 'Socket: {socket_path}' && "
+            f"exit 1; "
+            f"fi",
+        ],
+        _sudo=True,
+    )
+
     # Update nginx upstream config to point to target slot
     _update_nginx_upstream(host_data, app_name, target_slot)
 
@@ -899,7 +943,6 @@ def activate_bluegreen(host_data):
 
     # Update state.json on remote
     prev_slot = active_slot or "none"
-    socket_path = get_slot_socket_path(app_name, target_slot)
     server.shell(
         name=f"Set active slot to {target_slot}",
         commands=[set_active_slot_cmd(state_file, target_slot)],

{djaploy-1.2.6 → djaploy-1.2.7}/djaploy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djaploy
-Version: 1.2.6
+Version: 1.2.7
 Summary: Modular Django deployment system based on pyinfra
 Author-email: Johanna Mae Dimayuga <johanna@techco.fi>
 License: MIT License

{djaploy-1.2.6 → djaploy-1.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "djaploy"
-version = "1.2.6"
+version = "1.2.7"
 description = "Modular Django deployment system based on pyinfra"
 authors = [
     {name = "Johanna Mae Dimayuga", email = "johanna@techco.fi"}

{djaploy-1.2.6 → djaploy-1.2.7}/tests/test_bluegreen.py

@@ -483,5 +483,122 @@ class TestBluegreenHookDiscovery(unittest.TestCase):
             global_registry._hooks.update(saved_hooks)
 
 
+class TestBluegreenHealthCheck(unittest.TestCase):
+    """Test health check logic in activate hook."""
+
+    def test_health_check_socket_path_uses_target_slot(self):
+        """Health check should curl the target slot's socket."""
+        from djaploy.infra.utils import get_slot_socket_path
+        blue_socket = get_slot_socket_path("myapp", "blue")
+        green_socket = get_slot_socket_path("myapp", "green")
+        self.assertEqual(blue_socket, "/run/myapp-blue/myapp.sock")
+        self.assertEqual(green_socket, "/run/myapp-green/myapp.sock")
+        # Sockets must be different so health check targets the right slot
+        self.assertNotEqual(blue_socket, green_socket)
+
+    def test_health_check_service_name_uses_target_slot(self):
+        """Health check fallback should check the target slot's service."""
+        from djaploy.infra.utils import get_slot_service_name
+        self.assertEqual(get_slot_service_name("myapp", "blue"), "myapp-blue")
+        self.assertEqual(get_slot_service_name("myapp", "green"), "myapp-green")
+
+    def test_health_check_command_structure(self):
+        """Verify the health check shell command contains the expected elements."""
+        # Simulate what activate_bluegreen generates
+        app_name = "testapp"
+        target_slot = "green"
+        from djaploy.infra.utils import get_slot_socket_path
+        socket_path = get_slot_socket_path(app_name, target_slot)
+
+        # Build the command the same way the hook does
+        cmd = (
+            f"if curl -sf --max-time 5 --unix-socket {socket_path} http://localhost/ > /dev/null 2>&1; then "
+            f"echo 'Health check passed: {target_slot} slot is responding'; "
+            f"else "
+            f"if [ -S {socket_path} ] && systemctl is-active {app_name}-{target_slot}.service > /dev/null 2>&1; then "
+            f"echo 'Health check: {target_slot} slot service is active (HTTP response may be non-200, proceeding)'; "
+            f"else "
+            f"echo 'ACTIVATION ABORTED: {target_slot} slot is not responding.' && "
+            f"echo 'Socket: {socket_path}' && "
+            f"echo 'Check: systemctl status {app_name}-{target_slot}.service' && "
+            f"exit 1; "
+            f"fi; "
+            f"fi"
+        )
+
+        # Must curl the correct socket
+        self.assertIn(f"--unix-socket /run/testapp-green/testapp.sock", cmd)
+        # Must check the correct service on fallback
+        self.assertIn("systemctl is-active testapp-green.service", cmd)
+        # Must abort with exit 1 on failure
+        self.assertIn("exit 1", cmd)
+        # Must include the abort message
+        self.assertIn("ACTIVATION ABORTED", cmd)
+
+    def test_health_check_different_slots_produce_different_commands(self):
+        """Blue and green health checks should target different sockets."""
+        from djaploy.infra.utils import get_slot_socket_path
+        blue_cmd = f"curl --unix-socket {get_slot_socket_path('app', 'blue')}"
+        green_cmd = f"curl --unix-socket {get_slot_socket_path('app', 'green')}"
+        self.assertIn("app-blue", blue_cmd)
+        self.assertIn("app-green", green_cmd)
+        self.assertNotEqual(blue_cmd, green_cmd)
+
+
+class TestBluegreenServiceExistenceCheck(unittest.TestCase):
+    """Test that start_services checks unit file existence before starting."""
+
+    def test_service_check_command_structure(self):
+        """The start command should test for the unit file before starting."""
+        from djaploy.infra.utils import get_slot_service_name
+        slot_service = get_slot_service_name("myapp", "blue")
+
+        # Build the command the same way start_services does
+        cmd = (
+            f"test -f /etc/systemd/system/{slot_service}.service && "
+            f"systemctl enable {slot_service} && "
+            f"systemctl restart {slot_service} || "
+            f"echo 'Unit {slot_service}.service not found, skipping'"
+        )
+
+        self.assertIn("test -f /etc/systemd/system/myapp-blue.service", cmd)
+        self.assertIn("systemctl enable myapp-blue", cmd)
+        self.assertIn("systemctl restart myapp-blue", cmd)
+        self.assertIn("not found, skipping", cmd)
+
+    def test_streaming_service_gets_separate_slot_name(self):
+        """bostad-streaming should produce bostad-streaming-blue, not bostad-blue."""
+        from djaploy.infra.utils import get_slot_service_name
+        self.assertEqual(
+            get_slot_service_name("bostad-streaming", "blue"),
+            "bostad-streaming-blue",
+        )
+        self.assertEqual(
+            get_slot_service_name("bostad-streaming", "green"),
+            "bostad-streaming-green",
+        )
+
+
+class TestHeredocInjectionSafety(unittest.TestCase):
+    """Test that state.json update safely handles special characters."""
+
+    def test_release_name_with_quotes_is_safe(self):
+        """json.dumps should escape quotes in release names."""
+        import json
+        release = "feat/o'hare"
+        safe = json.dumps(release)
+        self.assertEqual(safe, '"feat/o\'hare"')
+        # Should be parseable back
+        self.assertEqual(json.loads(safe), release)
+
+    def test_commit_with_special_chars_is_safe(self):
+        """json.dumps should handle commit messages with special chars."""
+        import json
+        commit = 'fix: handle "edge" case'
+        safe = json.dumps(commit)
+        self.assertIn('\\"edge\\"', safe)
+        self.assertEqual(json.loads(safe), commit)
+
+
 if __name__ == "__main__":
     unittest.main()