menzeljandClaude Opus 5
09bed274eb
F7 — Nothing stopped two compose operations landing on the same stack. There was a busy flag, but is_busy() was only ever read to colour the status column; no lifecycle handler consulted it before acting. Two tabs, or auto-update picking up a stack somebody had just clicked, both ran pull + up -d against the same project and raced over recreating containers. Lifecycle calls, the two deploy WebSockets and the auto-update pass now take a real lock; a second caller gets 409 (or an error frame and close 4409) and auto-update skips and retries next cycle. The lock is a row rather than a set in one worker's memory, so it holds across workers and across a restart, and it carries an expiry — a worker killed mid-deploy would otherwise strand the stack with no fix short of editing the database. F10 — /api/stacks/stats sampled every running container on every call, one blocking daemon request each, and both the dashboard and the stacks list poll it every five seconds. Two tabs on a 40-container host meant a sustained ~16 samples a second. Cached for 4s behind a lock so concurrent callers share one sweep, the same shape dashboard_service already used for its fleet aggregate. F11 — Three module dicts assumed exactly one uvicorn worker without saying so and were lost on restart. The busy set is the lock above. The image update cache is now mirrored to SQLite, so a restart shows the badges immediately instead of blanking them for up to an hour, and the already-notified marks come back with them rather than re-announcing the same updates. The login rate limiter is a table, so it cannot be cleared by getting the process to restart and no longer multiplies by the worker count. The constraint that shaped this: compose_service and update_service are shared with the agent, which has no database. Neither may import one. So the lock is a separate service the central app enforces at its own entry points, and update persistence is an opt-in callback the central app registers in its lifespan — the agent registers nothing and behaves exactly as before. A test asserts update_service never imports the database, since that is the kind of thing a later change breaks silently. Both new nets were checked by reverting the fix: dropping the lock from _lifecycle fails six tests, removing the stats cache fails the one that names the behaviour. Also wires up cache pruning in the same sweep — without it both the dict and the table grew one entry per image tag ever run, for the life of the install. 31 new tests (729 total). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Dk43rmEeRfYi5wsLDbmfyG
81 lines
2.7 KiB
Python
81 lines
2.7 KiB
Python
"""Persistence for the image update cache.
|
|
|
|
``update_service`` holds the registry-digest results in a module dict because
|
|
it is shared with the agent, which has no database. This module is the central
|
|
app's half: it seeds that dict at startup and mirrors every write back into
|
|
SQLite, wired up in ``main.lifespan``.
|
|
|
|
What it buys: after a restart the update badges are there immediately instead
|
|
of blank until the next background sweep (up to an hour), and the "already
|
|
notified" marks come back with them, so a restart no longer re-announces
|
|
updates the user has already seen.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
|
|
from sqlmodel import Session, select
|
|
|
|
from database import engine
|
|
from models.runtime_state import ImageStatus
|
|
from services import update_service
|
|
|
|
logger = logging.getLogger("stackpilot.image_status")
|
|
|
|
|
|
def _to_status(row: ImageStatus) -> update_service.UpdateStatus:
|
|
return update_service.UpdateStatus(
|
|
image=row.image,
|
|
update_available=row.update_available,
|
|
current_digest=row.current_digest,
|
|
remote_digest=row.remote_digest,
|
|
checked_at=row.checked_at,
|
|
error=row.error,
|
|
)
|
|
|
|
|
|
def save(status: update_service.UpdateStatus, notified: bool) -> None:
|
|
"""Upsert one image's status. Opens its own session — the caller is the
|
|
background loop, which has none."""
|
|
with Session(engine) as session:
|
|
row = session.get(ImageStatus, status.image)
|
|
if row is None:
|
|
row = ImageStatus(image=status.image)
|
|
row.update_available = status.update_available
|
|
row.current_digest = status.current_digest
|
|
row.remote_digest = status.remote_digest
|
|
row.checked_at = status.checked_at
|
|
row.error = status.error
|
|
row.notified = notified
|
|
session.add(row)
|
|
session.commit()
|
|
|
|
|
|
def install() -> int:
|
|
"""Seed the in-memory cache from the database and start mirroring writes.
|
|
|
|
Returns how many entries were restored.
|
|
"""
|
|
with Session(engine) as session:
|
|
rows = session.exec(select(ImageStatus)).all()
|
|
update_service.restore_cache([(_to_status(r), r.notified) for r in rows])
|
|
update_service.set_persist_callback(save, prune)
|
|
return len(rows)
|
|
|
|
|
|
def prune(keep: set[str]) -> int:
|
|
"""Drop rows for images that are no longer used by any stack.
|
|
|
|
Without this the table grows for the life of the install, one row per image
|
|
tag that was ever running.
|
|
"""
|
|
removed = 0
|
|
with Session(engine) as session:
|
|
for row in session.exec(select(ImageStatus)).all():
|
|
if row.image not in keep:
|
|
session.delete(row)
|
|
removed += 1
|
|
if removed:
|
|
session.commit()
|
|
return removed
|