diff --git a/REPORT.md b/REPORT.md index b91db7f..d91293e 100644 --- a/REPORT.md +++ b/REPORT.md @@ -156,7 +156,7 @@ Dispatcher просыпается по `NOTIFY outbox` (сразу после CO ### Очистка staging -Worker удаляет `staging/` сразу после COMMIT ready и ack. Если не успел (упал, S3 недоступен) — janitor удаляет исходник ready-вложения, обновлённого больше 60 с назад. Исходник failed хранится `STAGING_RETENTION_SECONDS=86400` (для replay), потом удаляется с событием `staging_expired`. queued/processing janitor не трогает никогда. Объекты под `attachments//` удаляются, только если вложения нет, оно failed или ключ не входит в опубликованный набор ready. +Worker удаляет `staging/` сразу после COMMIT ready и ack. Если не успел (упал, S3 недоступен) — janitor удаляет исходник ready-вложения, обновлённого больше 60 с назад. Исходник failed хранится `STAGING_RETENTION_SECONDS=86400` (для replay), потом удаляется с событием `staging_expired`. queued/processing janitor не трогает никогда. Объекты под `attachments//` удаляются, только если вложения нет, оно ready и ключ не входит в опубликованный набор, или оно failed и исходник уже удалён по retention (replay невозможен — конечное состояние). Повторная проверка и DELETE выполняются в одной транзакции под `FOR SHARE` на строке вложения: replay (`FOR UPDATE`) и worker ждут её завершения. ### Соответствие `.env.example` @@ -195,6 +195,7 @@ Worker удаляет `staging/` сразу после COMMIT ready и ack. | 4: timeout/lease для зависшего processing | `test_jobs.py lease`, `limits` | зависший не продлевает аренду → через ~15 с job возвращена и выполнена другим потоком, поздний результат отклонён fencing; живой долгий — аренда продлевается | jobs-crash.txt, jobs-limits.txt | | 4: ограниченная конкуренция/prefetch | `test_jobs.py concurrency` | 2 consumer, `prefetch_count=1`, ручной ack; из 8 накопленных заданий в processing одновременно ровно 2 | jobs-concurrency.txt | | 4: очистка staging после безопасной фиксации | `test_jobs.py worker-down`, `staging` | staging удалён worker'ом после COMMIT; после crash до очистки — janitor | jobs-recovery.txt, jobs-crash.txt | +| Исправлено по ревью: гонка janitor и replay | `test_janitor_replay.py` | на старом коде janitor удалял crop.jpg после replay (503), теперь все 4 файла 200; после истечения retention остатки удаляются, replay отказывает | evidence/jobs-janitor-replay.txt | | Выбранный трек 5 | — | не выбран | — | **Где проверено сейчас.** Все строки таблицы выше подтверждены на Docker-стенде из этого репозитория (Windows 10, Docker Desktop, Compose 2.35, образы из `compose.yaml`, 2 реплики API за балансировщиком): 24.10.2026 один полный прогон `python student-tests/collect_evidence.py` — все 26 шагов PASS, сводка в `evidence/summary.md`, вывод каждого шага в `evidence/*.txt`, таблицы замеров ниже взяты из того же прогона. Перед ним на том же стенде отдельно прошли `docker compose up -d --build --wait` (migrate и s3-init — Exited (0), остальные healthy), `python tests/smoke.py` и `python student-tests/test_jobs.py worker-down`. Ранний прогон процессами без Docker (PostgreSQL 16, RabbitMQ 3.12, SeaweedFS 3.80, Redis) сохранён в `evidence/native-sandbox/` для сравнения. diff --git a/evidence/jobs-janitor-replay.txt b/evidence/jobs-janitor-replay.txt new file mode 100644 index 0000000..dfad10b --- /dev/null +++ b/evidence/jobs-janitor-replay.txt @@ -0,0 +1,13 @@ +# jobs-janitor-replay: lab5: janitor does not delete objects re-written by replay (review fix) +# date: 2026-10-26 13:37:58, commit: 9863bb0 + uncommitted changes +# command: python.exe student-tests/test_janitor_replay.py +# exit code: 0, 186.4 s + +race-replayable: failed/retry_exhausted after a crash post-PUT; leftover objects ['v1/crop.jpg', 'v1/optimized.webp', 'v1/original', 'v1/thumbnail.jpg'] +race-terminal: failed/retry_exhausted after a crash post-PUT; leftover objects ['v1/crop.jpg', 'v1/optimized.webp', 'v1/original', 'v1/thumbnail.jpg'] +waiting 83 s until the leftovers are older than grace (120 s) +janitor pass over the bucket: did not try to delete any object of the replayable failed attachment +ops replay -> job 6d86b987-d46f-489a-84db-ea63e1c89579 ready +after the janitor pass: original/thumbnail/crop/optimized -> 200, 4 objects in S3; janitor report: orphans 0, deleted 0 +retention expired (STAGING_RETENTION_SECONDS=1 for this pass): staging source removed, leftovers of the failed attachment swept; replay refused: "source file is no longer in staging (retention expired)" +1 passed, 0 failed diff --git a/evidence/summary.md b/evidence/summary.md index 71fc1f1..02b6a43 100644 --- a/evidence/summary.md +++ b/evidence/summary.md @@ -11,6 +11,7 @@ | jobs-outbox | lab5: dispatcher crash between COMMIT and publish / after confirm | PASS | 15 | evidence/jobs-outbox.txt | | jobs-crash | lab5: worker crash after S3 PUT / after COMMIT before ack, staging cleanup, frozen worker lease | PASS | 156 | evidence/jobs-crash.txt | | jobs-retry | lab5: backoff+jitter, retry_exhausted, replay, permanent errors, DLQ | PASS | 70 | evidence/jobs-retry.txt | +| jobs-janitor-replay | lab5: janitor does not delete objects re-written by replay (review fix) | PASS | 186 | evidence/jobs-janitor-replay.txt | | jobs-concurrency | lab5: WORKER_CONCURRENCY consumers, prefetch 1, bounded processing | PASS | 15 | evidence/jobs-concurrency.txt | | attachments | lab4: files, limits, damaged images, MIME, filenames, access, attachment_ids | PASS | 10 | evidence/attachments.txt | | s3-security | lab4: private bucket outside API, limited API key, no console/ports, idempotent bootstrap | PASS | 10 | evidence/s3-security.txt | diff --git a/janitor.py b/janitor.py index 559c87d..91c7e3d 100644 --- a/janitor.py +++ b/janitor.py @@ -14,9 +14,13 @@ 3. Outbox: опубликованные строки старше OUTBOX_RETENTION_SECONDS удаляются. 4. Обход bucket по всем prefix (объекты старше grace): - staging/, originals/: сирота, если ни одна строка не ссылается на ключ как source_key; - - attachments//...: сирота, если вложения нет, оно failed, или оно ready, но ключ не входит - в его опубликованный набор (оригинал + варианты). У queued/processing объекты не трогаются: - их перезапишет следующая попытка теми же ключами. + - attachments//...: сирота, только если вложение в КОНЕЧНОМ состоянии и ключ ему не нужен: + вложения нет; оно failed и replay уже невозможен (source_key IS NULL — исходник удалён по retention); + оно ready, но ключ не входит в опубликованный набор (оригинал + варианты). У queued/processing + и у failed с исходником в staging объекты не трогаются: replay/следующая попытка перезапишет их + теми же ключами, и удаление устаревшим проходом сломало бы новый результат. + Повторная проверка и DELETE выполняются в одной транзакции под FOR SHARE на строке вложения: + replay (FOR UPDATE) и захват worker'ом (UPDATE) ждут конца DELETE, а не идут параллельно с ним. Отчёт о ready-вложениях без объекта в bucket (missing) — только отчёт, это потеря данных. Grace (ATTACHMENT_GRACE_SECONDS, по умолчанию 1 ч) больше любой живой загрузки/попытки, поэтому @@ -156,7 +160,7 @@ def classify_final(conn, keys: list[str]) -> set[str]: pass unique = list(set(ids.values())) rows = {r["id"]: r for r in conn.execute( - """SELECT a.id, a.state, a.object_key, + """SELECT a.id, a.state, a.object_key, a.source_key, ARRAY(SELECT v.object_key FROM attachment_variants v WHERE v.attachment_id = a.id AND v.pipeline_version = a.pipeline_version) AS variant_keys FROM attachments a WHERE a.id = ANY(%s)""", (unique,)).fetchall()} @@ -164,7 +168,11 @@ def classify_final(conn, keys: list[str]) -> set[str]: for key in keys: attachment_id = ids.get(key) row = rows.get(attachment_id) if attachment_id else None - if row is None or row["state"] == "failed": + if row is None: + orphans.add(key) + elif row["state"] == "failed" and row["source_key"] is None: + # failed без исходника — конечное состояние: replay отказывает («source file is no longer in + # staging»), других переходов из failed нет, поэтому никто больше не запишет эти ключи. orphans.add(key) elif row["state"] == "ready" and key != row["object_key"] and key not in row["variant_keys"]: orphans.add(key) @@ -186,10 +194,29 @@ def sweep_objects(conn, grace: int, dry_run: bool) -> dict: "SELECT source_key FROM attachments WHERE source_key = ANY(%s)", (keys,)).fetchall()} return {key for key in keys if key not in known} - def still_orphan(prefix, key): - if prefix == storage.FINAL_PREFIX: - return key in classify_final(conn, [key]) - return conn.execute("SELECT 1 FROM attachments WHERE source_key = %s", (key,)).fetchone() is None + def delete_if_orphan(prefix, key) -> bool: + """Повторная проверка прямо перед удалением и DELETE — атомарно относительно replay/worker.""" + if prefix != storage.FINAL_PREFIX: + # staging/originals: строка-указатель создаётся ДО PUT, ключ случайный и не переиспользуется, + # поэтому «нет строки сейчас» означает «не будет никогда». + if conn.execute("SELECT 1 FROM attachments WHERE source_key = %s", (key,)).fetchone() is not None: + return False + storage.delete(key) + return True + match = FINAL_KEY_RE.match(key) + try: + attachment_id = UUID(match.group(1)) if match else None + except ValueError: + attachment_id = None + with conn.transaction(): + if attachment_id is not None: + # FOR SHARE совместим с FOR KEY SHARE (вставка сообщения со ссылкой на вложение), но + # конфликтует с FOR UPDATE replay и с UPDATE worker'а: состояние не изменится до COMMIT. + conn.execute("SELECT 1 FROM attachments WHERE id = %s FOR SHARE", (attachment_id,)) + if key not in classify_final(conn, [key]): + return False + storage.delete(key) # S3 недоступен -> исключение, транзакция откатится, повтор на след. проходе + return True def check(prefix, items): nonlocal orphans, orphans_deleted @@ -198,8 +225,7 @@ def sweep_objects(conn, grace: int, dry_run: bool) -> dict: if key not in candidates or modified >= cutoff: continue orphans += 1 - if not dry_run and still_orphan(prefix, key): # повторная проверка прямо перед удалением - storage.delete(key) + if not dry_run and delete_if_orphan(prefix, key): orphans_deleted += 1 log.info("deleted orphan object %s", key) diff --git a/student-tests/collect_evidence.py b/student-tests/collect_evidence.py index c44bb68..1f65a1f 100644 --- a/student-tests/collect_evidence.py +++ b/student-tests/collect_evidence.py @@ -29,6 +29,8 @@ STEPS = [ [PY, "student-tests/test_jobs.py", "crash-after-put", "crash-after-commit", "staging", "lease"]), ("jobs-retry", "lab5: backoff+jitter, retry_exhausted, replay, permanent errors, DLQ", [PY, "student-tests/test_jobs.py", "retry", "exhausted-replay", "permanent", "dlq"]), + ("jobs-janitor-replay", "lab5: janitor does not delete objects re-written by replay (review fix)", + [PY, "student-tests/test_janitor_replay.py"]), ("jobs-concurrency", "lab5: WORKER_CONCURRENCY consumers, prefetch 1, bounded processing", [PY, "student-tests/test_jobs.py", "concurrency"]), ("attachments", "lab4: files, limits, damaged images, MIME, filenames, access, attachment_ids", diff --git a/student-tests/test_janitor_replay.py b/student-tests/test_janitor_replay.py new file mode 100644 index 0000000..4706a93 --- /dev/null +++ b/student-tests/test_janitor_replay.py @@ -0,0 +1,154 @@ +"""Регрессия: janitor не должен удалять объекты, которые replay записывает заново. + +Дефект (найден на ревью): у failed-вложения остаются объекты под attachments//v1/ (например, worker упал +после PUT, затем попытки исчерпаны). Janitor считал их сиротами, хотя failed ещё можно повторить (исходник +в staging хранится STAGING_RETENTION_SECONDS). Повторная проверка и DELETE не были синхронизированы с replay: +janitor, приостановленный после проверки, удалял crop.jpg, только что записанный успешным replay, +а метаданные оставались ready -> /content?variant=crop -> 503. + +Сценарий воспроизводит ровно это чередование: janitor запускается в контейнере janitor с перехватом +storage.delete — перед удалением любого объекта этого вложения он печатает PAUSED и ждёт; в это время тест +делает штатный ops.py replay и ждёт ready, потом отпускает janitor. Ожидание после исправления: janitor +вообще не пытается удалить объекты failed-вложения, пока replay возможен; после replay все 4 файла — 200. +Вторая часть: когда исходник удалён по retention (replay больше невозможен — состояние конечное), +оставшиеся объекты failed-вложения удаляются, а replay отказывает. + + python student-tests/test_janitor_replay.py +Длительность ~4 мин (объекты должны стать старше grace = 120 с, минимально допустимого). +""" +import json +import subprocess +import threading +import time + +from common import ROOT, call, check, run_tests, wait_ready +from test_jobs import (clear_faults, content, fault, get, image, log, ops, probe, upload, user_and_chat, + wait_status, job) + +GRACE = 120 # минимально допустимый grace: 2 x UPLOAD_TIMEOUT_SECONDS + +HOOK = r''' +import json, pathlib, sys, time +import janitor, storage +attachment_id, grace = sys.argv[1], int(sys.argv[2]) +prefix = f"attachments/{attachment_id}/" +release = pathlib.Path("/tmp/janitor-release-" + attachment_id) +real_delete = storage.delete +deleted = [] +def delete(key, *args, **kwargs): + if key.startswith(prefix): + print("PAUSED " + key, flush=True) # проверка уже пройдена, DELETE ещё не выполнен + deadline = time.time() + 120 + while not release.exists() and time.time() < deadline: + time.sleep(0.2) + deleted.append(key) + return real_delete(key, *args, **kwargs) +storage.delete = delete +report = None +for _ in range(60): # фоновый janitor может держать advisory lock + report = janitor.run_once(grace, False) + if report is not None: + break + time.sleep(2) +print(json.dumps({"report": report, "deleted_ours": deleted}), flush=True) +''' + + +def exec_python(service, code, *args, env=None): + command = ["docker", "compose", "exec", "-T"] + for name, value in (env or {}).items(): + command += ["-e", f"{name}={value}"] + command += [service, "python", "-", *map(str, args)] + result = subprocess.run(command, cwd=ROOT, input=code.encode(), capture_output=True, check=False) + check(result.returncode == 0, f"{service}: {result.stderr.decode('utf-8', 'replace')[-500:]}") + return result.stdout.decode("utf-8", "replace") + + +def failed_with_leftovers(name): + """failed/retry_exhausted, у которого под attachments//v1/ остались объекты прерванной попытки.""" + clear_faults() + fault("worker_crash_after_put") # попытка 1: объекты записаны, worker убит до COMMIT + att = upload(image("thumb320"), filename=f"{name}.png") + deadline = time.monotonic() + 30 + while len(probe("inspect", att["id"])["final_keys"]) < 4: + check(time.monotonic() < deadline, "attempt 1 did not write its objects") + time.sleep(0.3) + written = time.monotonic() + fault("worker_s3_error", 4) # попытки 2-5: временная ошибка S3 -> retry_exhausted + failed = wait_status(att["id"], ("failed", "ready"), 120) + check(failed["status"] == "failed" and failed["error_code"] == "retry_exhausted", f"{name}: {failed}") + keys = probe("inspect", att["id"])["final_keys"] + check(len(keys) == 4, f"{name}: leftovers expected, got {keys}") + log(f"{name}: failed/retry_exhausted after a crash post-PUT; leftover objects {keys}") + return att, written + + +def test_janitor_does_not_delete_replayed_objects(): + user_and_chat() + a, written_a = failed_with_leftovers("race-replayable") + b, written_b = failed_with_leftovers("race-terminal") + wait = max(written_a, written_b) + GRACE + 5 - time.monotonic() # объекты ОБОИХ старше grace + if wait > 0: + log(f"waiting {wait:.0f} s until the leftovers are older than grace ({GRACE} s)") + time.sleep(wait) + + # 1. janitor проходит bucket; если решит удалить объект A — остановится перед DELETE + proc = subprocess.Popen(["docker", "compose", "exec", "-T", "janitor", "python", "-", a["id"], str(GRACE)], + cwd=ROOT, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL) + proc.stdin.write(HOOK.encode()) + proc.stdin.close() + lines = [] + reader = threading.Thread(target=lambda: lines.extend(l.decode().strip() for l in proc.stdout), daemon=True) + reader.start() + deadline = time.monotonic() + 60 + while not any(l.startswith("PAUSED") for l in lines) and proc.poll() is None: + check(time.monotonic() < deadline, "janitor pass did not finish") + time.sleep(0.2) + paused = [l for l in lines if l.startswith("PAUSED")] + log(f"janitor pass over the bucket: {'paused before DELETE of ' + paused[0][7:] if paused else 'did not try to delete any object of the replayable failed attachment'}") + + # 2. штатный replay, пока janitor стоит (или уже прошёл) + j = job(a["id"]) + check("replayed" in ops("replay", j["job_id"], "--reason", "janitor race regression"), "replay refused") + wait_status(a["id"], "ready", 60) + log(f"ops replay -> job {j['job_id']} ready") + + # 3. отпускаем janitor и ждём конца прохода + exec_python("janitor", "import pathlib, sys\npathlib.Path('/tmp/janitor-release-' + sys.argv[1]).touch()\n", a["id"]) + proc.wait(timeout=120) + reader.join(timeout=5) + result = json.loads([l for l in lines if l.startswith("{")][-1]) + check(result["report"] is not None, "janitor pass did not run") + + # 4. результат replay цел + for variant in ("original", "thumbnail", "crop", "optimized"): + content(a["id"], variant, expected=200) + info = probe("inspect", a["id"]) + check(info["final_keys"] == ["v1/crop.jpg", "v1/optimized.webp", "v1/original", "v1/thumbnail.jpg"], + f"objects after the janitor pass: {info['final_keys']}") + check(not result["deleted_ours"], f"janitor deleted objects of the replayed attachment: {result['deleted_ours']}") + log("after the janitor pass: original/thumbnail/crop/optimized -> 200, 4 objects in S3; " + f"janitor report: orphans {result['report']['orphan_objects']}, deleted {result['report']['orphan_objects_deleted']}") + + # 5. B всё ещё можно повторить -> его остатки тоже не тронуты + check(len(probe("inspect", b["id"])["final_keys"]) == 4, "leftovers of a replayable failed attachment deleted") + + # 6. retention истёк -> исходника нет, replay невозможен (конечное состояние) -> остатки удаляются + terminal = exec_python("janitor", "import janitor, json, sys, time\n" + "for _ in range(60):\n" + " r = janitor.run_once(int(sys.argv[1]), False)\n" + " if r is not None:\n break\n time.sleep(2)\n" + "print(json.dumps(r))\n", GRACE, env={"STAGING_RETENTION_SECONDS": "1"}) + left = probe("inspect", b["id"])["final_keys"] + check(left == [], f"leftovers of a terminal failed attachment must be swept, got {left}; janitor: " + f"{terminal.strip().splitlines()[-1]}") + refused = ops("replay", job(b["id"])["job_id"]) + check("refused" in refused and "staging" in refused["refused"], f"replay must be refused: {refused}") + check(get(b["id"])["status"] == "failed", "terminal attachment must stay failed") + log(f"retention expired (STAGING_RETENTION_SECONDS=1 for this pass): staging source removed, leftovers of " + f"the failed attachment swept; replay refused: \"{refused['refused']}\"") + + +if __name__ == "__main__": + wait_ready() + run_tests([test_janitor_does_not_delete_replayed_objects])