alissa-tools-github-revloop 0.16.7__tar.gz → 0.16.8__tar.gz

{alissa_tools_github_revloop-0.16.7/src/main/alissa_tools_github_revloop.egg-info → alissa_tools_github_revloop-0.16.8}/PKG-INFO

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

{alissa_tools_github_revloop-0.16.7 → alissa_tools_github_revloop-0.16.8}/src/main/alissa/tools/github/revloop/loop.py

@@ -181,8 +181,9 @@ CHECKS_UNSETTLED_LEAD = (
     "concluded.**\n\n"
     "{detail}\n\n"
     "This round's verdict was held for {waited} min waiting for the head's "
-    "checks to settle ({bound} min bound) and they did not, so it is recorded "
-    "as a comment: an approve would claim a head this loop never saw go green. "
+    "checks to settle ({bound} min bound){total_note} and they did not, so it is "
+    "recorded as a comment: an approve would claim a head this loop never saw go "
+    "green. "
     "Nothing about the review itself changed — the verdict below is the round's "
     "own.\n\n"
     "Submitting this review consumes the pending review request, so the daemon "
@@ -221,6 +222,13 @@ CHECKS_UNSETTLED_PAGE = (
     "No label was touched and no further round is queued."
 )
 
+# Appended to `{bound}` above only when the hold was PROMOTED -- an unreadable
+# wait that became a genuine pending one restarts the clock, so the bound the
+# operator configured applies per condition and the round can be held up to
+# twice it. Saying "held 30 min (30 min bound)" after 60 real minutes is the
+# report being wrong about the one number an operator tunes.
+CHECKS_TOTAL_HELD = ", {total} min in total across both waits,"
+
 # The `{detail}` above, per reason the rollup did not settle.
 CHECKS_STILL_RUNNING = "Still running at the bound: {names}."
 CHECKS_UNREADABLE = (
@@ -1165,22 +1173,29 @@ class ReviewWatcher:
         # never "restart whenever the state changes" -- a reader flapping between
         # the two would then push the bound out forever, which is precisely the
         # unbounded hold this bound exists to prevent.
-        held_at, held_state = self.state.checks_hold(pr.full_name, pr.number, round_)
-        promoted = held_state == CHECKS_UNKNOWN and rollup.state == CHECKS_PENDING
-        if held_at is None or promoted:
-            held_at = self.state.record_checks_hold(
+        hold = self.state.checks_hold(pr.full_name, pr.number, round_)
+        promoted = hold.condition == CHECKS_UNKNOWN and rollup.state == CHECKS_PENDING
+        if hold.since is None or promoted:
+            self.state.record_checks_hold(
                 pr.full_name, pr.number, round_, rollup.state
             )
-        waited = max(time.time() - held_at, 0)
+            hold = self.state.checks_hold(pr.full_name, pr.number, round_)
+        # Two numbers, both reported: `waited` is the wait THIS condition has had
+        # and is what the bound applies to; `held` is how long the round has been
+        # held at all. They differ by up to a full bound once a hold has been
+        # promoted, so a report that shows only the first tells an operator who
+        # set 30 minutes that a 60-minute hold waited 30.
+        waited = max(time.time() - (hold.since or time.time()), 0)
+        held = max(time.time() - (hold.first_at or time.time()), 0)
         bound = self.config.checks_wait_seconds
         if waited < bound:
             # One line per poll, one activity note per held round; see
             # checks_hold_kind.
             log.info(
-                "%s round %d: holding its %s — CI rollup at %s is %s (%dm of the "
-                "%dm bound waited)",
+                "%s round %d: holding its %s — CI rollup at %s is %s (%dm on this "
+                "condition of the %dm bound; %dm held in total)",
                 pr.slug, round_, VERDICT_APPROVE, judged[:8], rollup.summary,
-                waited // 60, bound // 60,
+                waited // 60, bound // 60, held // 60,
             )
             self._note_checks_hold(pr, round_, judged, rollup)
             return ChecksGate(
@@ -1188,7 +1203,8 @@ class ReviewWatcher:
                     Action.AWAITING_POST,
                     f"round {round_} holds its {VERDICT_APPROVE} — the CI rollup "
                     f"at {judged[:8]} is {rollup.summary}; "
-                    f"{int((bound - waited) // 60)}m of the wait bound left",
+                    f"{int((bound - waited) // 60)}m of the wait bound left "
+                    f"({int(held // 60)}m held in total)",
                     round_,
                     task_ref=task.ref,
                 ),
@@ -1196,10 +1212,10 @@ class ReviewWatcher:
             )
 
         log.warning(
-            "%s round %d: the CI rollup at %s is still %s after %dm — recording "
-            "the %s envelope as a %s review, never an APPROVE on an unverified "
-            "head",
-            pr.slug, round_, judged[:8], rollup.summary, waited // 60,
+            "%s round %d: the CI rollup at %s is still %s after %dm on this "
+            "condition (%dm held in total) — recording the %s envelope as a %s "
+            "review, never an APPROVE on an unverified head",
+            pr.slug, round_, judged[:8], rollup.summary, waited // 60, held // 60,
             VERDICT_APPROVE, EVENT_COMMENT,
         )
         detail = (
@@ -1216,6 +1232,11 @@ class ReviewWatcher:
                 detail=detail,
                 waited=int(waited // 60),
                 bound=int(bound // 60),
+                total_note=(
+                    CHECKS_TOTAL_HELD.format(total=int(held // 60))
+                    if hold.promoted
+                    else ""
+                ),
             ),
             state=rollup.state,
             detail=detail,

{alissa_tools_github_revloop-0.16.7 → alissa_tools_github_revloop-0.16.8}/src/main/alissa/tools/github/revloop/state.py

@@ -29,6 +29,7 @@ import json
 import sqlite3
 import time
 from collections.abc import Iterable
+from dataclasses import dataclass
 from pathlib import Path
 
 # Poll-snapshot retention: the newest N rows are kept, older ones pruned on
@@ -108,10 +109,9 @@ CREATE TABLE IF NOT EXISTS verdict_posts (
     -- then released rather than held open forever; see loop._abandon_verdict.
     abandoned_at  INTEGER,
     -- When this round's APPROVE was FIRST held back because the judged head's
-    -- CI rollup had not settled. The wait bound is measured from here, so a
-    -- rollup that never concludes degrades the verdict to a comment at a fixed
-    -- distance from the first observation rather than from whenever the last
-    -- poll happened to land. NULL means the gate never held this round.
+    -- CI rollup had not settled -- and it is never overwritten afterwards, so
+    -- "how long has this round really been held?" always has an answer. NULL
+    -- means the gate never held this round.
     checks_held_at INTEGER,
     -- WHICH unsettled condition that stamp belongs to ('pending' -- checks are
     -- genuinely running -- or 'unknown' -- the rollup could not be read). The
@@ -121,6 +121,13 @@ CREATE TABLE IF NOT EXISTS verdict_posts (
     -- 'pending' one. The policy lives in loop._gate_on_checks; this column is
     -- what lets it be decided from the ledger instead of from memory.
     checks_held_state TEXT,
+    -- When that promotion happened: the stamp the bound is measured from once
+    -- the wait is on checks that are genuinely running. Separate from
+    -- `checks_held_at` rather than replacing it, because the two answer
+    -- different questions and a report that conflates them says a promoted hold
+    -- waited one bound when it waited two. NULL until (and unless) the promotion
+    -- happens; the bound then reads `checks_pending_at or checks_held_at`.
+    checks_pending_at INTEGER,
     review_url    TEXT,
     last_error    TEXT,
     PRIMARY KEY (repo, number, round)
@@ -163,10 +170,42 @@ _ADDED_COLUMNS = {
     "verdict_posts": (
         ("checks_held_at", "INTEGER"),
         ("checks_held_state", "TEXT"),
+        ("checks_pending_at", "INTEGER"),
     ),
 }
 
 
+@dataclass(frozen=True)
+class ChecksHold:
+    """One round's CI hold, as the ledger remembers it.
+
+    Two stamps, because the gate has two honest numbers to report and they can
+    differ by a whole wait bound:
+
+    * `first_at` -- when the round was first held at all, on whatever condition;
+    * `pending_at` -- when an unreadable hold was promoted to a genuinely
+      pending one, which restarts the clock the bound is measured from (see
+      loop._gate_on_checks for why exactly once).
+
+    `since` is the one the bound uses. `first_at` is the one an operator means by
+    "how long has this been held?", and reporting only `since` after a promotion
+    understates it by up to the full bound.
+    """
+
+    first_at: int | None = None
+    condition: str | None = None
+    pending_at: int | None = None
+
+    @property
+    def since(self) -> int | None:
+        """The stamp the wait bound is measured from."""
+        return self.pending_at or self.first_at
+
+    @property
+    def promoted(self) -> bool:
+        return self.pending_at is not None
+
+
 class State:
     def __init__(self, path: Path, *, read_only: bool = False):
         """Open the ledger. The daemon opens it read-write (creating the file,
@@ -509,38 +548,59 @@ class State:
         row = self.get_verdict_post(repo, number, round_)
         return int(row["attempts"]) if row else 0
 
-    def checks_hold(
-        self, repo: str, number: int, round_: int
-    ) -> "tuple[int | None, str | None]":
-        """When this round's approve was first held on CI, and on WHICH
-        condition -- (None, None) if it has never been held.
+    def checks_hold(self, repo: str, number: int, round_: int) -> "ChecksHold":
+        """This round's CI hold: when it began, what it is waiting on, and when
+        that became a genuine `pending` -- an all-None ChecksHold if it has never
+        been held.
 
         A read, deliberately: whether an existing stamp still applies is a
         policy question about CI (see loop._gate_on_checks), and this table's job
-        is to remember the answer, not to make it.
+        is to remember the answer, not to make it. It remembers BOTH stamps
+        because the two answer different questions -- `since` bounds the wait,
+        `first_at` is how long the round has really been held -- and a report
+        that conflates them tells an operator a promoted hold waited 30 minutes
+        when it waited 60.
         """
         row = self.get_verdict_post(repo, number, round_)
         if row is None or not row["checks_held_at"]:
-            return None, None
-        return int(row["checks_held_at"]), (row["checks_held_state"] or None)
+            return ChecksHold()
+        pending_at = row["checks_pending_at"]
+        return ChecksHold(
+            first_at=int(row["checks_held_at"]),
+            condition=(row["checks_held_state"] or None),
+            pending_at=int(pending_at) if pending_at else None,
+        )
 
     def record_checks_hold(
         self, repo: str, number: int, round_: int, condition: str
     ) -> int:
-        """Start (or restart) the hold clock for this round; return the stamp.
+        """Record that this round is held on `condition`; return the stamp the
+        bound is measured from.
 
         The caller decides WHEN to call this -- once when the hold begins, and at
         most once more when an unreadable hold is promoted to a genuinely pending
         one, because the bound is defined against the first observation of the
-        condition actually being waited on. Unconditional here so that policy
-        stays in one place instead of being half-expressed as a WHERE clause.
+        condition actually being waited on (loop._gate_on_checks owns that rule).
+
+        The promotion NO LONGER overwrites `checks_held_at`: it fills
+        `checks_pending_at` instead, so the ledger keeps when the round was first
+        held as well as when its current wait started. Nothing about the bound
+        changes; what changes is that the daemon can now say both numbers out
+        loud, which the operator-facing report needs.
         """
         now = int(time.time())
-        self._db.execute(
-            "UPDATE verdict_posts SET checks_held_at = ?, checks_held_state = ? "
-            "WHERE repo=? AND number=? AND round=?",
-            (now, condition, repo, number, round_),
-        )
+        if self.checks_hold(repo, number, round_).first_at is None:
+            self._db.execute(
+                "UPDATE verdict_posts SET checks_held_at = ?, checks_held_state = ? "
+                "WHERE repo=? AND number=? AND round=?",
+                (now, condition, repo, number, round_),
+            )
+        else:
+            self._db.execute(
+                "UPDATE verdict_posts SET checks_pending_at = ?, "
+                "checks_held_state = ? WHERE repo=? AND number=? AND round=?",
+                (now, condition, repo, number, round_),
+            )
         self._db.commit()
         return now
 
@@ -603,7 +663,7 @@ class State:
         return self._read_rows(
             "SELECT repo, number, round, first_seen_at, head_sha, attempts, "
             "last_attempt_at, posted_at, abandoned_at, checks_held_at, "
-            "checks_held_state, review_url, last_error "
+            "checks_held_state, checks_pending_at, review_url, last_error "
             "FROM verdict_posts "
             "ORDER BY first_seen_at DESC, number DESC",
             limit,

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

@@ -0,0 +1 @@
+0.16.8

{alissa_tools_github_revloop-0.16.7 → alissa_tools_github_revloop-0.16.8/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.16.7
+Version: 0.16.8
 Summary: ALISSA-TOOLS-GITHUB-REVLOOP
 Home-page: https://alissa.app
 Author: Fahera

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

@@ -1 +0,0 @@
-0.16.7