alissa-tools-github-revloop 0.31.17__tar.gz → 0.31.18__tar.gz

{alissa_tools_github_revloop-0.31.17/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.31.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.31.17
+Version: 0.31.18
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

{alissa_tools_github_revloop-0.31.17 → alissa_tools_github_revloop-0.31.18}/src/main/alissa/tools/github/revloop/loop.py

@@ -6302,20 +6302,49 @@ class ReviewWatcher:
         #157): claim the spawn of this round's session against the drain
         flag, run `spawn` under the claim, and drop the claim however it ends.
 
-        The gate sits ABOVE every side effect of the spawn -- the hub add,
-        the `alissa tmux queue add`, the census bump, the ledger row, the
-        activity line -- so a drained seat touches nothing, and the round
-        stays owed: a QUEUED `drained` decision writes no spawn row, burns no
-        round number and spends no attempt, exactly like the slot gate. The
-        claim and the flag are read and written in one immediate transaction
-        on each side (`State.claim_spawn` / `State.set_drain`): a drain that
+        The gate sits ABOVE every side effect of the spawn but one -- the
+        `alissa tmux queue add`, the census bump, the ledger row and the
+        activity line all come after it -- and a round it stands down stays
+        owed: a QUEUED `drained` decision writes no spawn row, burns no round
+        number and spends no attempt, exactly like the slot gate. The claim
+        and the flag are read and written in one immediate transaction on
+        each side (`State.claim_spawn` / `State.set_drain`): a drain that
         lands while this spawn is between its gate and its ledger write sees
-        the claim and refuses itself, so a park can never race a spawn. A
-        ledger that cannot answer stands the spawn down too -- a spawn that
-        cannot prove the seat is not drained does not happen.
+        the claim and refuses itself. A ledger that cannot answer stands the
+        spawn down too -- a spawn that cannot prove the seat is not drained
+        does not happen.
+
+        The claim only counts for `parking.SPAWN_CLAIM_TTL`, and the hub add
+        (`_ensure_hub`, a clone on a PR's first round) can outlast it. So
+        `_spawn_claimed` re-takes the claim (`_claim_spawn` again, issue
+        #173) between the hub add and the enqueue, which refreshes it and
+        re-reads the flag: a drain that held while the hub was provisioned
+        stands the round down there, the same QUEUED `drained` way. That late
+        re-check is the one stand-down that happens AFTER a side effect --
+        the hub is provisioned and stays -- which is harmless, because the
+        hub is a reusable cache the round's next spawn finds in place.
+        Together the two claims mean a park can never race a spawn, whatever
+        the drain's freshness rule allows.
 
         Dry-run READS the flag and claims nothing: it shares the production
         state path, and a dry pass must write no durable row."""
+        refused = self._claim_spawn(pr, round_, name)
+        if refused is not None:
+            return refused
+        try:
+            return spawn()
+        finally:
+            if not self.config.dry_run:
+                self.state.release_spawn(name)
+
+    def _claim_spawn(
+        self, pr: PullRequest, round_: int, name: str, *, late: bool = False,
+    ) -> "Decision | None":
+        """Claim (or, `late`, re-claim) the spawn of `name` against the drain
+        flag: None when the spawn may proceed, else the QUEUED `drained`
+        decision that stands the round down. Dry-run reads the flag and
+        claims nothing. See `_drain_gated`."""
+        where = " after its hub was provisioned" if late else ""
         try:
             if self.config.dry_run:
                 drain = self.state.drain()
@@ -6323,36 +6352,32 @@ class ReviewWatcher:
                 drain = self.state.claim_spawn(name)
         except sqlite3.Error as exc:
             log.warning(
-                "%s round %d: could not claim the spawn against the drain flag "
-                "(%s) — standing it down this pass", pr.slug, round_, exc,
-            )
-            return Decision(
-                Action.QUEUED,
-                f"round {round_} stood down — the state ledger could not prove "
-                f"the seat is not drained ({exc}); retrying next poll",
-                round_,
-                drained=True,
-            )
-        if drain is not None:
-            since = parking_mod.iso(drain["drained_at"])
-            until = parking_mod.iso(drain["expires_at"])
-            log.info(
-                "%s round %d: not spawning — the seat is drained for parking "
-                "since %s (until %s)", pr.slug, round_, since, until,
+                "%s round %d: could not claim the spawn against the drain flag%s "
+                "(%s) — standing it down this pass", pr.slug, round_, where, exc,
             )
             return Decision(
                 Action.QUEUED,
-                f"round {round_} held — the seat is drained for parking since "
-                f"{since} (until {until}: {drain['reason'] or 'no reason given'}); "
-                f"retrying once it is undrained",
+                f"round {round_} stood down{where} — the state ledger could not "
+                f"prove the seat is not drained ({exc}); retrying next poll",
                 round_,
                 drained=True,
             )
-        try:
-            return spawn()
-        finally:
-            if not self.config.dry_run:
-                self.state.release_spawn(name)
+        if drain is None:
+            return None
+        since = parking_mod.iso(drain["drained_at"])
+        until = parking_mod.iso(drain["expires_at"])
+        log.info(
+            "%s round %d: not spawning%s — the seat is drained for parking "
+            "since %s (until %s)", pr.slug, round_, where, since, until,
+        )
+        return Decision(
+            Action.QUEUED,
+            f"round {round_} held{where} — the seat is drained for parking since "
+            f"{since} (until {until}: {drain['reason'] or 'no reason given'}); "
+            f"retrying once it is undrained",
+            round_,
+            drained=True,
+        )
 
     def _spawn_claimed(
         self,
@@ -6427,6 +6452,14 @@ class ReviewWatcher:
             # provisioned -- unknown, never settled.
             return Decision(Action.SKIPPED, problem, round_, owed=True)
 
+        # The hub add can outlast the gate's claim (a clone on a PR's first
+        # round): re-take it, refreshing it and re-reading the drain flag, so
+        # a drain that landed meanwhile stands the round down here (issue
+        # #173). The claim is still released in `_drain_gated`'s finally.
+        refused = self._claim_spawn(pr, round_, name, late=True)
+        if refused is not None:
+            return refused
+
         self.alissa.enqueue_reviewer(
             session=name,
             directive=directive,

{alissa_tools_github_revloop-0.31.17 → alissa_tools_github_revloop-0.31.18}/src/main/alissa/tools/github/revloop/parking.py

@@ -26,7 +26,9 @@ handshake):
   reads every null as a refusal.
 * **The drain.** A flag with a TTL in `state.db` (`State.set_drain`), cleared
   when the daemon boots. While it holds, the round spawn stands down before
-  its first side effect (`ReviewWatcher._drain_gated`).
+  its first side effect (`ReviewWatcher._drain_gated`), or, when the drain
+  lands while the hub is provisioned, after the hub add and before the
+  enqueue (the post-hub re-claim).
 """
 
 from __future__ import annotations

{alissa_tools_github_revloop-0.31.17 → alissa_tools_github_revloop-0.31.18}/src/main/alissa/tools/github/revloop/state.py

@@ -39,6 +39,8 @@ from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from pathlib import Path
 
+from .parking import SPAWN_CLAIM_TTL
+
 log = logging.getLogger(__name__)
 
 # Poll-snapshot retention: the newest N rows are kept, older ones pruned on
@@ -2067,11 +2069,12 @@ class State:
 
     def set_drain(
         self, ttl: int, reason: str, now: "float | None" = None,
-        claim_ttl: int = 600,
+        claim_ttl: int = SPAWN_CLAIM_TTL,
     ) -> "tuple[dict, list[dict]]":
         """Raise the drain flag for `ttl` seconds and return it with the spawn
-        claims standing at that instant (younger than `claim_ttl` -- an older
-        one is a spawn whose process died mid-way, cleared at the next boot).
+        claims standing at that instant (younger than `claim_ttl`, by default
+        `parking.SPAWN_CLAIM_TTL` -- an older one is a spawn whose process
+        died mid-way, cleared at the next boot).
         ONE immediate transaction, so a spawn either claimed before this (and
         is in the list) or claims after it (and sees the flag). A drain that
         is already up is replaced: a re-drain restarts the TTL. Raises

alissa_tools_github_revloop-0.31.18/src/main/alissa/tools/github/revloop/version

@@ -0,0 +1 @@
+0.31.18

{alissa_tools_github_revloop-0.31.17 → alissa_tools_github_revloop-0.31.18}/src/main/alissa/tools/github/revloop/webui/server.py

@@ -332,7 +332,9 @@ class App:
             cleared = self.sources.clear_drain()
         except sqlite3.Error as exc:
             self._audit("undrain", {"ok": False, "error": str(exc)})
-            return 503, {"drained": True, "error": "state_unavailable"}
+            # The flag's state is unknown here, and unknown is never a value
+            # (D2): the 503 already says the undrain did not land.
+            return 503, {"drained": None, "error": "state_unavailable"}
         self._audit("undrain", {"ok": True, "cleared": cleared})
         return 200, {"drained": False, "cleared": cleared}
 

{alissa_tools_github_revloop-0.31.17 → alissa_tools_github_revloop-0.31.18/src/main/alissa_tools_github_revloop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alissa-tools-github-revloop
-Version: 0.31.17
+Version: 0.31.18
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

alissa_tools_github_revloop-0.31.17/src/main/alissa/tools/github/revloop/version

@@ -1 +0,0 @@
-0.31.17