feat: control-plane DB substrate for atomic assign/lease (Closes #613)
Add SQLite single-writer MVP control plane per the allocator ADR: sessions, work_items (issue/pr only), atomic assign+lease, mutation gates, terminal-lock index, and provider-neutral incident_links. DB coordinates concurrency; Gitea remains assignable work; raw Sentry/GlitchTip incidents are never work items. #600 and #612 build on this substrate.
This commit is contained in:
@@ -0,0 +1,377 @@
|
||||
"""Tests for control-plane DB substrate (#613)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
from datetime import timedelta
|
||||
|
||||
from control_plane_db import (
|
||||
ControlPlaneDB,
|
||||
InvalidWorkKindError,
|
||||
LeaseRequiredError,
|
||||
WORK_KINDS,
|
||||
_ts,
|
||||
_utc_now,
|
||||
)
|
||||
|
||||
|
||||
class ControlPlaneDBTest(unittest.TestCase):
|
||||
def setUp(self) -> None:
|
||||
self._tmp = tempfile.TemporaryDirectory()
|
||||
self.db_path = os.path.join(self._tmp.name, "cp.sqlite3")
|
||||
self.db = ControlPlaneDB(self.db_path)
|
||||
|
||||
def tearDown(self) -> None:
|
||||
self._tmp.cleanup()
|
||||
|
||||
def test_schema_and_architecture_meta(self) -> None:
|
||||
import sqlite3
|
||||
|
||||
conn = sqlite3.connect(self.db_path)
|
||||
try:
|
||||
rows = dict(conn.execute("SELECT key, value FROM schema_meta").fetchall())
|
||||
finally:
|
||||
conn.close()
|
||||
self.assertEqual(rows["schema_version"], "1")
|
||||
self.assertIn("DB coordinates", rows["architecture"])
|
||||
self.assertIn("bridge", rows["architecture"].lower())
|
||||
|
||||
def test_rejects_raw_incident_as_work_kind(self) -> None:
|
||||
with self.assertRaises(InvalidWorkKindError):
|
||||
self.db.upsert_work_item(
|
||||
remote="prgs",
|
||||
org="org",
|
||||
repo="repo",
|
||||
kind="sentry_incident",
|
||||
number=1,
|
||||
)
|
||||
with self.assertRaises(InvalidWorkKindError):
|
||||
self.db.assign_and_lease(
|
||||
session_id="s1",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="org",
|
||||
repo="repo",
|
||||
kind="glitchtip_incident",
|
||||
number=9,
|
||||
)
|
||||
self.assertEqual(WORK_KINDS, frozenset({"issue", "pr"}))
|
||||
|
||||
def test_atomic_assign_and_lease_fields(self) -> None:
|
||||
self.db.upsert_session(session_id="s-a", role="author", profile="prgs-author")
|
||||
result = self.db.assign_and_lease(
|
||||
session_id="s-a",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="Scaled-Tech-Consulting",
|
||||
repo="Gitea-Tools",
|
||||
kind="issue",
|
||||
number=613,
|
||||
expected_head_sha="abc123",
|
||||
allowed_actions=("implement", "comment"),
|
||||
forbidden_actions=("approve", "merge"),
|
||||
)
|
||||
self.assertEqual(result.outcome, "assigned")
|
||||
self.assertIsNotNone(result.assignment_id)
|
||||
self.assertIsNotNone(result.lease_id)
|
||||
self.assertEqual(result.role, "author")
|
||||
self.assertEqual(result.work_kind, "issue")
|
||||
self.assertEqual(result.work_number, 613)
|
||||
self.assertEqual(result.expected_head_sha, "abc123")
|
||||
self.assertIn("implement", result.allowed_actions)
|
||||
self.assertIn("merge", result.forbidden_actions)
|
||||
self.assertIsNotNone(result.expires_at)
|
||||
|
||||
def test_second_session_waits_on_foreign_lease(self) -> None:
|
||||
self.db.upsert_session(session_id="s1", role="author")
|
||||
self.db.upsert_session(session_id="s2", role="author")
|
||||
first = self.db.assign_and_lease(
|
||||
session_id="s1",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="pr",
|
||||
number=100,
|
||||
expected_head_sha="deadbeef",
|
||||
)
|
||||
self.assertEqual(first.outcome, "assigned")
|
||||
second = self.db.assign_and_lease(
|
||||
session_id="s2",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="pr",
|
||||
number=100,
|
||||
expected_head_sha="deadbeef",
|
||||
)
|
||||
self.assertEqual(second.outcome, "wait")
|
||||
self.assertEqual(second.owner_session_id, "s1")
|
||||
|
||||
def test_owner_resume_refreshes_lease(self) -> None:
|
||||
self.db.upsert_session(session_id="s1", role="reviewer")
|
||||
a = self.db.assign_and_lease(
|
||||
session_id="s1",
|
||||
role="reviewer",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="pr",
|
||||
number=50,
|
||||
)
|
||||
b = self.db.assign_and_lease(
|
||||
session_id="s1",
|
||||
role="reviewer",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="pr",
|
||||
number=50,
|
||||
)
|
||||
self.assertEqual(b.outcome, "assigned")
|
||||
self.assertEqual(b.lease_id, a.lease_id)
|
||||
self.assertIn("owner-resume", b.reason)
|
||||
|
||||
def test_require_valid_assignment_gates_mutations(self) -> None:
|
||||
self.db.upsert_session(session_id="s1", role="author")
|
||||
self.db.assign_and_lease(
|
||||
session_id="s1",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=7,
|
||||
allowed_actions=("implement",),
|
||||
forbidden_actions=("merge",),
|
||||
)
|
||||
proof = self.db.require_valid_assignment(
|
||||
session_id="s1",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=7,
|
||||
action="implement",
|
||||
)
|
||||
self.assertEqual(proof["session_id"], "s1")
|
||||
with self.assertRaises(LeaseRequiredError):
|
||||
self.db.require_valid_assignment(
|
||||
session_id="s1",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=7,
|
||||
action="merge",
|
||||
)
|
||||
with self.assertRaises(LeaseRequiredError):
|
||||
self.db.require_valid_assignment(
|
||||
session_id="s-other",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=7,
|
||||
action="implement",
|
||||
)
|
||||
|
||||
def test_expired_lease_allows_reassign(self) -> None:
|
||||
self.db.upsert_session(session_id="s1", role="author")
|
||||
self.db.upsert_session(session_id="s2", role="author")
|
||||
past = _utc_now() - timedelta(hours=1)
|
||||
# Create lease already expired by using negative TTL edge via direct assign then expire
|
||||
assigned = self.db.assign_and_lease(
|
||||
session_id="s1",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=3,
|
||||
lease_ttl_seconds=1,
|
||||
)
|
||||
self.assertEqual(assigned.outcome, "assigned")
|
||||
# Force expiry in DB
|
||||
import sqlite3
|
||||
|
||||
conn = sqlite3.connect(self.db_path)
|
||||
try:
|
||||
conn.execute(
|
||||
"UPDATE leases SET expires_at = ? WHERE lease_id = ?",
|
||||
(_ts(past), assigned.lease_id),
|
||||
)
|
||||
conn.commit()
|
||||
finally:
|
||||
conn.close()
|
||||
n = self.db.expire_stale_leases()
|
||||
self.assertGreaterEqual(n, 1)
|
||||
second = self.db.assign_and_lease(
|
||||
session_id="s2",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=3,
|
||||
)
|
||||
self.assertEqual(second.outcome, "assigned")
|
||||
self.assertEqual(second.session_id, "s2")
|
||||
|
||||
def test_merged_work_never_assigned(self) -> None:
|
||||
self.db.upsert_session(session_id="s1", role="merger")
|
||||
self.db.upsert_work_item(
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="pr",
|
||||
number=99,
|
||||
state="merged",
|
||||
)
|
||||
result = self.db.assign_and_lease(
|
||||
session_id="s1",
|
||||
role="merger",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="pr",
|
||||
number=99,
|
||||
)
|
||||
self.assertEqual(result.outcome, "no_safe_work")
|
||||
|
||||
def test_four_concurrent_sessions_unique_assignments(self) -> None:
|
||||
"""Four concurrent assigners on four different issues — all succeed uniquely.
|
||||
|
||||
Also two concurrent assigners on the *same* issue: at most one assigned.
|
||||
"""
|
||||
for i in range(4):
|
||||
self.db.upsert_session(session_id=f"sess-{i}", role="author")
|
||||
|
||||
def claim_unique(i: int):
|
||||
return self.db.assign_and_lease(
|
||||
session_id=f"sess-{i}",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=1000 + i,
|
||||
)
|
||||
|
||||
with ThreadPoolExecutor(max_workers=4) as pool:
|
||||
results = [f.result() for f in as_completed([pool.submit(claim_unique, i) for i in range(4)])]
|
||||
self.assertEqual({r.outcome for r in results}, {"assigned"})
|
||||
numbers = sorted(r.work_number for r in results)
|
||||
self.assertEqual(numbers, [1000, 1001, 1002, 1003])
|
||||
|
||||
# Contention on one item
|
||||
self.db.upsert_session(session_id="c1", role="author")
|
||||
self.db.upsert_session(session_id="c2", role="author")
|
||||
self.db.upsert_session(session_id="c3", role="author")
|
||||
self.db.upsert_session(session_id="c4", role="author")
|
||||
barrier = threading.Barrier(4)
|
||||
outcomes: list[str] = []
|
||||
lock = threading.Lock()
|
||||
|
||||
def contend(sid: str) -> None:
|
||||
barrier.wait()
|
||||
res = self.db.assign_and_lease(
|
||||
session_id=sid,
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=7777,
|
||||
)
|
||||
with lock:
|
||||
outcomes.append(res.outcome)
|
||||
|
||||
threads = [threading.Thread(target=contend, args=(f"c{i}",)) for i in range(1, 5)]
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
self.assertEqual(outcomes.count("assigned"), 1)
|
||||
self.assertEqual(outcomes.count("wait"), 3)
|
||||
|
||||
def test_terminal_lock_index(self) -> None:
|
||||
self.db.set_terminal_lock(
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
terminal_pr=332,
|
||||
review_id="rev-1",
|
||||
decision="approve",
|
||||
)
|
||||
row = self.db.get_active_terminal_lock(remote="prgs", org="o", repo="r")
|
||||
self.assertIsNotNone(row)
|
||||
assert row is not None
|
||||
self.assertEqual(row["terminal_pr"], 332)
|
||||
self.assertEqual(row["status"], "active")
|
||||
|
||||
def test_incident_links_not_work_items(self) -> None:
|
||||
link = self.db.upsert_incident_link(
|
||||
provider="sentry",
|
||||
provider_base_url="https://sentry.prgs.cc",
|
||||
provider_org="prgs",
|
||||
provider_project="gitea-tools-mcp",
|
||||
provider_issue_id="12345",
|
||||
gitea_org="Scaled-Tech-Consulting",
|
||||
gitea_repo="Gitea-Tools",
|
||||
gitea_issue_number=9001,
|
||||
fingerprint="fp-1",
|
||||
)
|
||||
self.assertEqual(link["gitea_issue_number"], 9001)
|
||||
found = self.db.get_incident_link_for_gitea_issue(
|
||||
gitea_org="Scaled-Tech-Consulting",
|
||||
gitea_repo="Gitea-Tools",
|
||||
gitea_issue_number=9001,
|
||||
)
|
||||
self.assertIsNotNone(found)
|
||||
# Linking does not create a work_item of incident kind
|
||||
with self.assertRaises(InvalidWorkKindError):
|
||||
self.db.upsert_work_item(
|
||||
remote="prgs",
|
||||
org="Scaled-Tech-Consulting",
|
||||
repo="Gitea-Tools",
|
||||
kind="sentry",
|
||||
number=12345,
|
||||
)
|
||||
|
||||
def test_heartbeat_and_release(self) -> None:
|
||||
self.db.upsert_session(session_id="s1", role="author")
|
||||
a = self.db.assign_and_lease(
|
||||
session_id="s1",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=1,
|
||||
)
|
||||
hb = self.db.heartbeat_lease(a.lease_id, session_id="s1")
|
||||
self.assertEqual(hb["lease_id"], a.lease_id)
|
||||
self.db.release_lease(a.lease_id, session_id="s1")
|
||||
# After release another session can claim
|
||||
self.db.upsert_session(session_id="s2", role="author")
|
||||
b = self.db.assign_and_lease(
|
||||
session_id="s2",
|
||||
role="author",
|
||||
remote="prgs",
|
||||
org="o",
|
||||
repo="r",
|
||||
kind="issue",
|
||||
number=1,
|
||||
)
|
||||
self.assertEqual(b.outcome, "assigned")
|
||||
self.assertEqual(b.session_id, "s2")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user