djaploy 1.6.1__tar.gz → 1.6.2__tar.gz

{djaploy-1.6.1 → djaploy-1.6.2}/PKG-INFO

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

{djaploy-1.6.1 → djaploy-1.6.2}/djaploy/deploy.py

@@ -61,7 +61,15 @@ def run_command(context: Dict[str, Any]) -> None:
     call_hook(f"{command_name}:precommand", context)
     call_hook("precommand", context)
 
-    # 2. Run pyinfra
+    # 2. Run pyinfra (unless a precommand hook already did all the work,
+    #    e.g. the gitops strategy, which has no remote hooks)
+    if context.get("skip_remote"):
+        print(f"No remote execution needed ({context['skip_remote']}).", flush=True)
+        context["success"] = True
+        call_hook(f"{command_name}:postcommand", context)
+        call_hook("postcommand", context)
+        return
+
     print("Starting remote execution...", flush=True)
     processed_inventory = _preprocess_inventory(str(context["inventory_file"]))
 

{djaploy-1.6.1 → djaploy-1.6.2}/djaploy/infra/gitops.py

@@ -15,8 +15,9 @@ pins its digest in the GitOps repository and syncs the Argo CD application:
       5. sync that commit in Argo CD and wait until Synced and Healthy
 
 The inventory host is the build node: its SSH connection (ssh_hostname,
-ssh_user, ssh_key, ssh_known_hosts_file) is used for the build, and no remote
-pyinfra hooks run. Kubernetes access uses the local kubeconfig.
+ssh_user, ssh_key, ssh_known_hosts_file) is used for the build over one
+multiplexed connection, retried if the connection drops. pyinfra is not run
+for gitops-only inventories. Kubernetes access uses the local kubeconfig.
 
 HostConfig fields used: app_name, manage_py_path, secret_key, data, and
 ``gitops_conf``::
@@ -50,7 +51,9 @@ import json
 import os
 import re
 import shlex
+import shutil
 import subprocess
+import tempfile
 import time
 import uuid
 from pathlib import Path
@@ -203,11 +206,23 @@ def check_infra_repo(repo: Path, manifest: str) -> str:
 
 
 class BuildNode:
-    """SSH to the build node with the inventory's connection settings."""
+    """SSH to the build node with the inventory's connection settings.
+
+    All commands share one multiplexed connection, so a build makes one SSH
+    handshake. A failed connection (ssh exit status 255) is retried: every
+    build-job command is safe to repeat, and an input stream is rewound first.
+    """
+
+    RETRIES = 3
 
     def __init__(self, host_data):
         self.target = f"{_get(host_data, 'ssh_user')}@{_get(host_data, 'ssh_hostname')}"
-        self.opts = ["-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=yes"]
+        # Short private directory: Unix socket paths are limited (~104 bytes on macOS).
+        self.control_dir = tempfile.mkdtemp(prefix="djaploy-ssh-", dir="/tmp")
+        self.opts = ["-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=yes",
+                     "-o", "ConnectTimeout=20", "-o", "ServerAliveInterval=15", "-o", "ServerAliveCountMax=4",
+                     "-o", "ControlMaster=auto", "-o", f"ControlPath={self.control_dir}/%C",
+                     "-o", "ControlPersist=120"]
         if _get(host_data, "ssh_port"):
             self.opts += ["-p", str(_get(host_data, "ssh_port"))]
         if _get(host_data, "ssh_key"):
@@ -216,7 +231,23 @@ class BuildNode:
             self.opts += ["-o", f"UserKnownHostsFile={_get(host_data, 'ssh_known_hosts_file')}"]
 
     def run(self, command: str, **kwargs):
-        return _run(["ssh", *self.opts, self.target, command], **kwargs)
+        stdin = kwargs.get("stdin")
+        for attempt in range(1, self.RETRIES + 1):
+            if attempt > 1 and hasattr(stdin, "seek"):
+                stdin.seek(0)
+            try:
+                return _run(["ssh", *self.opts, self.target, command], **kwargs)
+            except subprocess.CalledProcessError as exc:
+                if exc.returncode != 255 or attempt == self.RETRIES:
+                    raise
+                print(f"[gitops] SSH connection to {self.target} failed; retrying ({attempt}/{self.RETRIES - 1})",
+                      flush=True)
+                time.sleep(2 * attempt)
+
+    def close(self):
+        _run(["ssh", *self.opts, "-O", "exit", self.target], check=False,
+             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        shutil.rmtree(self.control_dir, ignore_errors=True)
 
 
 BUILDER_DEFAULTS = {
@@ -317,6 +348,7 @@ def build_and_push(host_data, artifact_path: Path, image: str, tag: str) -> str:
         result = json.loads(node.run(cmd["result"], capture_output=True, text=True).stdout)
     finally:
         node.run(cmd["cleanup"], check=False)
+        node.close()
     digest = result.get("containerimage.digest", "")
     if not DIGEST_RE.fullmatch(digest):
         raise RuntimeError(f"Build finished without a pushed digest: {result}")
@@ -399,6 +431,9 @@ def _gitops_deploy(context):
     gitops_hosts = [data for _, data in hosts if _get(data, "deployment_strategy") == GITOPS]
     if not gitops_hosts:
         return
+    if len(gitops_hosts) == len(hosts):
+        # No remote pyinfra hooks run for gitops hosts: don't connect at all.
+        context["skip_remote"] = "gitops deploys from this machine"
     if len(gitops_hosts) > 1:
         raise ValueError("gitops inventories deploy one app per environment; use one host")
     host_data = gitops_hosts[0]

djaploy-1.6.2/djaploy/version.py

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

{djaploy-1.6.1 → djaploy-1.6.2}/djaploy.egg-info/PKG-INFO

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

{djaploy-1.6.1 → djaploy-1.6.2}/pyproject.toml

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

{djaploy-1.6.1 → djaploy-1.6.2}/tests/test_gitops.py

@@ -181,6 +181,7 @@ class SyncOperationTests(unittest.TestCase):
 class BuildNodeTests(unittest.TestCase):
     def test_ssh_options_from_inventory(self):
         node = gitops.BuildNode(host(ssh_port=2222, ssh_known_hosts_file="/tmp/kh"))
+        self.addCleanup(lambda: __import__("shutil").rmtree(node.control_dir, ignore_errors=True))
         self.assertEqual(node.target, "janitor@203.0.113.10")
         self.assertIn("StrictHostKeyChecking=yes", node.opts)
         self.assertIn("UserKnownHostsFile=/tmp/kh", node.opts)
@@ -201,6 +202,9 @@ class FakeNode:
         stdout = '{"containerimage.digest": "%s"}' % NEW if command.endswith("result.json") else ""
         return subprocess.CompletedProcess(command, 0, stdout=stdout)
 
+    def close(self):
+        self.commands.append("<close>")
+
 
 class BuilderTests(unittest.TestCase):
     def setUp(self):
@@ -228,7 +232,8 @@ class BuilderTests(unittest.TestCase):
     def test_shared_build_sequence(self):
         node = FakeNode()
         self.assertEqual(self.build(node), NEW)
-        self.assertTrue(all(c.startswith("sudo -u builder ") for c in node.commands), node.commands)
+        self.assertEqual(node.commands[-1], "<close>")
+        self.assertTrue(all(c.startswith("sudo -u builder ") for c in node.commands[:-1]), node.commands)
         self.assertFalse(any("systemd-run" in c for c in node.commands))
         steps = ["mkdir -p", "tar --no-same-owner", "umask 077", "buildctl --addr", "/result.json", "rm -rf --"]
         positions = [next(i for i, c in enumerate(node.commands) if step in c and (step != "/result.json" or c.endswith(step))) for step in steps]
@@ -242,14 +247,64 @@ class BuilderTests(unittest.TestCase):
         node = FakeNode(fail_on=" build ")
         with self.assertRaises(subprocess.CalledProcessError):
             self.build(node)
-        self.assertTrue(node.commands[-1].startswith("sudo -u builder rm -rf -- /var/lib/techco-buildkit/jobs/"))
+        self.assertTrue(node.commands[-2].startswith("sudo -u builder rm -rf -- /var/lib/techco-buildkit/jobs/"))
+        self.assertEqual(node.commands[-1], "<close>")
 
     def test_temporary_mode_starts_its_own_daemon(self):
         node = FakeNode()
         self.assertEqual(self.build(node, mode="temporary"), NEW)
         self.assertTrue(any("systemd-run" in c for c in node.commands))
         self.assertTrue(any("/data/djaploy-build/docms-prod-abc1234-" in c for c in node.commands))
-        self.assertIn("systemctl stop djaploy-buildkit-", node.commands[-1])
+        self.assertIn("systemctl stop djaploy-buildkit-", node.commands[-2])
+
+
+class BuildNodeConnectionTests(unittest.TestCase):
+    def setUp(self):
+        self.node = gitops.BuildNode(host())
+        self.addCleanup(lambda: __import__("shutil").rmtree(self.node.control_dir, ignore_errors=True))
+        patcher = patch.object(gitops.time, "sleep")
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def test_one_multiplexed_connection_with_keepalives(self):
+        self.assertTrue(self.node.control_dir.startswith("/tmp/djaploy-ssh-"))
+        self.assertIn(f"ControlPath={self.node.control_dir}/%C", self.node.opts)
+        for opt in ("ControlMaster=auto", "ServerAliveInterval=15", "ConnectTimeout=20"):
+            self.assertIn(opt, self.node.opts)
+
+    def test_connection_failure_is_retried_and_input_rewound(self):
+        failures = [subprocess.CalledProcessError(255, "ssh")]
+        seen = []
+
+        def fake_run(cmd, **kwargs):
+            seen.append(kwargs["stdin"].read())
+            if failures:
+                raise failures.pop()
+            return subprocess.CompletedProcess(cmd, 0)
+
+        with tempfile.TemporaryFile() as archive, patch.object(gitops, "_run", side_effect=fake_run):
+            archive.write(b"source")
+            archive.seek(0)
+            self.node.run("tar -xzf -", stdin=archive)
+        self.assertEqual(seen, [b"source", b"source"])
+
+    def test_command_failure_is_not_retried(self):
+        with patch.object(gitops, "_run", side_effect=subprocess.CalledProcessError(1, "ssh")) as run:
+            with self.assertRaises(subprocess.CalledProcessError):
+                self.node.run("false")
+        self.assertEqual(run.call_count, 1)
+
+    def test_gives_up_after_retries(self):
+        with patch.object(gitops, "_run", side_effect=subprocess.CalledProcessError(255, "ssh")) as run:
+            with self.assertRaises(subprocess.CalledProcessError):
+                self.node.run("true")
+        self.assertEqual(run.call_count, gitops.BuildNode.RETRIES)
+
+    def test_close_stops_master_and_removes_socket_dir(self):
+        with patch.object(gitops, "_run") as run:
+            self.node.close()
+        self.assertIn("-O", run.call_args[0][0])
+        self.assertFalse(Path(self.node.control_dir).exists())
 
 
 def git(cwd, *args):
@@ -310,6 +365,7 @@ class HookTests(unittest.TestCase):
             context = self.context([("extor", host())])
             gitops._gitops_deploy(context)
         self.assertEqual(calls, ["check", "build", "secret", "pin", "sync"])
+        self.assertTrue(context["skip_remote"])
         self.assertEqual(context["gitops"], {"image": f"{IMAGE}@{NEW}", "revision": "f" * 40})
 
     def test_build_failure_publishes_nothing(self):
@@ -326,6 +382,14 @@ class HookTests(unittest.TestCase):
             gitops._gitops_deploy(self.context([("web", host(deployment_strategy="zero_downtime"))]))
         check.assert_not_called()
 
+    def test_mixed_inventory_keeps_remote_stage(self):
+        with patch.object(gitops, "check_infra_repo", return_value="main"), \
+             patch.object(gitops, "build_and_push", return_value=NEW), patch.object(gitops, "apply_env_secret"), \
+             patch.object(gitops, "publish_pin", return_value="f" * 40), patch.object(gitops, "sync_and_wait"):
+            context = self.context([("extor", host()), ("web", host(deployment_strategy="zero_downtime"))])
+            gitops._gitops_deploy(context)
+        self.assertNotIn("skip_remote", context)
+
     def test_one_host_only(self):
         with self.assertRaisesRegex(ValueError, "one host"):
             gitops._gitops_deploy(self.context([("a", host()), ("b", host())]))
@@ -333,3 +397,25 @@ class HookTests(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+
+class RunCommandSkipTests(unittest.TestCase):
+    def test_skip_remote_runs_no_pyinfra_but_postcommand(self):
+        from djaploy import deploy
+        called = []
+
+        def fake_call_hook(name, context):
+            called.append(name)
+            if name == "deploy:precommand":
+                context["skip_remote"] = "gitops deploys from this machine"
+            return []
+
+        context = {"command": "deploy", "env": "dev", "command_file": "x", "inventory_file": "inv.py",
+                   "pyinfra_data": {}}
+        with patch("djaploy.hooks.discover_hooks"), patch("djaploy.hooks.call_hook", side_effect=fake_call_hook), \
+             patch.object(deploy, "_run_pyinfra") as pyinfra, patch.object(deploy, "_preprocess_inventory") as pre:
+            deploy.run_command(context)
+        pyinfra.assert_not_called()
+        pre.assert_not_called()
+        self.assertTrue(context["success"])
+        self.assertEqual(called, ["deploy:precommand", "precommand", "deploy:postcommand", "postcommand"])

djaploy-1.6.1/djaploy/version.py

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