bvandeusenandClaude Opus 5
172e33de9a
CI / lint (push) Successful in 3s
CI / extension-version (push) Successful in 3s
Build images / sign-extension (push) Successful in 4s
Build images / build-agent (push) Successful in 7s
CI / frontend-build (push) Successful in 23s
CI / backend-lint-and-test (push) Successful in 36s
Build images / build-web (push) Successful in 1m9s
Build images / smoke-web (push) Skipped
Build images / build-ml (push) Successful in 2m8s
Build images / promote (push) Skipped
CI / integration (push) Successful in 2m37s
Milestone 422 step 5. `docker compose -f docker-compose.single.yml up -d` gives three containers — FabledCurator, Postgres, Redis — where the stack previously needed seven. THE MULTI-SERVICE STACK IS KEPT. docker-compose.yml still runs the five app services separately and remains the right shape for a Swarm deployment spread across hosts, where per-service rolling rollback and placement constraints matter. This adds a compose file; it deletes none. `entrypoint.sh all` GENERATES the supervisord config from worker_lanes.LANES and execs it as PID 1. Generated rather than checked in because a static .conf would spell out each lane's -Q list, making a FIFTH hand-kept copy of the queue names — after celery_app.task_routes and the three collapsed in steps 1, 2 and 4. Every one of those had already drifted when found. Generating gives a stronger guarantee than "they match today": a lane added to LANES gets a process, and a queue cannot end up with no consumer because someone missed a file. supervisord over s6-overlay: one pip dependency on an image already Python, with per-program stop timeouts and stopasgroup. The process-group part is not a detail — celery's prefork pool forks children, and a TERM reaching only the parent leaves them orphaned holding tasks. s6's advantage (PID-1 signal and zombie handling) comes from `init: true` instead. Nothing in FC talks to the supervisor, so the choice is reversible without touching product code. FOUR LANES, NOT FIVE. The ml lane is skipped: torch and the ML requirements live only in Dockerfile.ml until step 6 merges the images, so an `ml` program here would fail to import on every restart forever. `--with-ml` is the flag step 6 turns on. THREE BUGS FOUND BY READING IT BACK, none of which the first tests caught: 1. `environment=CELERY_QUEUES=default,import,thumbnail,download` — supervisord parses that key as a COMMA-separated list, so it reads as CELERY_QUEUES=default plus three malformed entries and the worker lane would have consumed only `default`. Silent: the worker starts, reports healthy, never picks up an import. Now quoted, and the test asserts the quoted form rather than the bare substring, which passed either way. 2. The generator emitted `entrypoint.sh <lane.name>`, but `maintenance_long` is not a role — compose runs it as the plain `worker` role with different queues. Lane now carries `entrypoint_role`, and a test reads entrypoint.sh to assert every role a lane names actually exists. 3. The `scheduler` role hardcoded --concurrency=1, ignoring CELERY_CONCURRENCY. Harmless while only compose started it and set none; with a generated value being passed, the lane would have sat at 1 until the reconcile noticed, with nothing saying why. The healthcheck asserts BOTH halves — hypercorn answers and every configured lane is answering the broker. That is the failure mode consolidation creates: docker can no longer see the lanes as separate services, so a web-only check would report a healthy container with every lane inside it dead. It deliberately ignores the `enabled` flag: a disabled lane still has a running process with its consumers cancelled, and marking the container unhealthy for turning tagging off would be wrong. stop_grace_period 200s, sized to the slowest lane (maintenance_long at 180s) rather than the average, with a test asserting no program's stopwaitsecs can exceed what compose allows. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LVjrnpQjRgHdvq95rASoiR
84 lines
2.7 KiB
Python
84 lines
2.7 KiB
Python
"""Container healthcheck for the single-container layout.
|
|
|
|
Milestone 422 step 5. Exit 0 healthy, non-zero unhealthy.
|
|
|
|
## Why this is not just "does :8080 answer"
|
|
|
|
In the multi-service stack every service has its OWN healthcheck, so a dead
|
|
worker turns that service unhealthy while web stays green — docker knows which
|
|
part failed. Collapsing them into one container collapses that too: a web-only
|
|
check would report a perfectly healthy container while every lane inside it
|
|
had crashed and been abandoned by supervisord after its retries.
|
|
|
|
So this asserts both halves: hypercorn answers, AND every lane this container
|
|
was configured to run is answering the broker.
|
|
|
|
## What it deliberately does NOT do
|
|
|
|
It does not read the database, and it does not consult the `enabled` flag. A
|
|
DISABLED lane still has a running process with its consumers cancelled (see
|
|
the config generator), so it answers `inspect` and is healthy. Health is
|
|
"is the process alive", and whether it should be consuming is a settings
|
|
question the reconcile owns — conflating them would make turning a lane off
|
|
in the UI mark the container unhealthy.
|
|
|
|
It also cannot distinguish "the broker is down" from "every lane is down",
|
|
and reports unhealthy either way. That is correct: a container that cannot
|
|
reach its broker is not serving, whichever half is at fault.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import sys
|
|
import urllib.error
|
|
import urllib.request
|
|
|
|
WEB_URL = "http://localhost:8080/api/health"
|
|
WEB_TIMEOUT = 5.0
|
|
|
|
|
|
def _web_ok() -> tuple[bool, str]:
|
|
try:
|
|
with urllib.request.urlopen(WEB_URL, timeout=WEB_TIMEOUT) as resp:
|
|
if resp.status == 200:
|
|
return True, ""
|
|
return False, f"web returned {resp.status}"
|
|
except (urllib.error.URLError, OSError) as exc:
|
|
return False, f"web unreachable: {exc}"
|
|
|
|
|
|
def _lanes_ok(*, with_ml: bool) -> tuple[bool, str]:
|
|
from ..services.worker_control import inspect_lanes_sync
|
|
from ..services.worker_lanes import LANES
|
|
|
|
expected = {
|
|
lane.name for lane in LANES
|
|
if with_ml or lane.name != "ml"
|
|
}
|
|
live = inspect_lanes_sync()
|
|
missing = sorted(n for n in expected if not live[n].present)
|
|
if missing:
|
|
return False, "lanes not answering: " + ", ".join(missing)
|
|
return True, ""
|
|
|
|
|
|
def main(argv: list[str] | None = None) -> int:
|
|
argv = sys.argv[1:] if argv is None else argv
|
|
with_ml = "--with-ml" in argv
|
|
|
|
ok, detail = _web_ok()
|
|
if not ok:
|
|
print(detail, file=sys.stderr)
|
|
return 1
|
|
|
|
ok, detail = _lanes_ok(with_ml=with_ml)
|
|
if not ok:
|
|
print(detail, file=sys.stderr)
|
|
return 1
|
|
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|