Files
mtusi2026lab5/src/janitor.py
T
zemiles a71b445019 Аудит F01, F11, F12, F13: гонка janitor/replay, версия pipeline, схема сообщения, срок задания
- F01: janitor под блокировкой jobs+attachments перепроверяет условие, снимает
  staging_key и только после COMMIT удаляет объект; replay перечитывает
  staging_key отдельным запросом под блокировкой вложения (в READ COMMITTED
  соединённые колонки могли остаться из старого снимка); тест трёх порядков,
  включая чередование из аудита (учебная пауза JANITOR_PAUSE_AFTER_SELECT_SECONDS)
- F11: pipeline_version пишется при создании вложения; API не стартует с
  неподдерживаемой версией
- F12: строгий разбор по jobs.schema.json (bool, RFC 3339, traceparent,
  tracestate); 17 случаев совпадают с jsonschema Draft 2020-12
- F13: единый срок задания на чтение staging, transform и запись; после срока
  аренда не продлевается, работа прерывается как processing_timeout
2026-11-13 20:56:05 +03:00

236 lines
13 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Сверка PostgreSQL <-> S3 и очистка (compose-сервис `janitor`). Lab5.
Prefix-ы bucket:
staging/<uuid> принятые оригиналы до публикации результата (attachments.staging_key);
attachments/<id>/v<ver>/<name> конечные объекты: original и варианты;
originals/<uuid> оригиналы lab4 (после миграции 004 — staging-объекты backfill-заданий);
health/, bootstrap/ служебные, не трогаются.
За один проход (под pg_try_advisory_lock):
1. abandoned: pending-строки старше grace (API упал до постановки в очередь, 202 не было)
-> удалить staging-объект, затем строку;
2. staging ready: у ready-вложения остался staging (worker не смог удалить после COMMIT)
-> удалить объект, staging_key = NULL;
3. staging failed: failed дольше STAGING_RETENTION_SECONDS -> удалить staging (replay после
этого невозможен: ops replay ответит refused_staging_expired). Для 2 и 3: под блокировкой
jobs+attachments условие проверяется заново, staging_key снимается и COMMIT, потом DELETE
в S3 — гонка с replay исключена (аудит F01);
4. orphan: объекты staging/, originals/, attachments/ старше grace, на которые не ссылается
ни одна строка (staging_key, object_key ready-вложения, attachment_variants), и вложение
не queued/processing -> удалить;
5. missing: ready без объекта оригинала или варианта -> ТОЛЬКО отчёт.
Текущую работу (queued/processing) janitor не удаляет никогда: её staging нужен worker.
Grace (ATTACHMENT_GRACE_SECONDS, 3600 с) многократно больше UPLOAD_TIMEOUT_SECONDS и
JOB_TIMEOUT_SECONDS, поэтому идущая загрузка/обработка не считается брошенной.
python src/janitor.py --once --dry-run | --once | --interval 300
"""
import argparse
import datetime as dt
import json
import logging
import os
import re
import sys
import time
import jobs
from server import OBJ, STORE
log = logging.getLogger("messenger.janitor")
JANITOR_LOCK_ID = 727002
PREFIXES = ("staging/", "originals/", "attachments/")
HEARTBEAT = "/tmp/janitor.heartbeat"
STAGING_RETENTION = int(os.environ.get("STAGING_RETENTION_SECONDS", "86400"))
# Только для теста гонки (student-tests/janitor_replay_race.py): пауза между выборкой
# кандидатов и их захватом — воспроизводит чередование «выбрал -> replay -> удаляю». Обычно 0.
PAUSE_AFTER_SELECT = float(os.environ.get("JANITOR_PAUSE_AFTER_SELECT_SECONDS", "0"))
_FINAL_RE = re.compile(r"^attachments/([0-9a-f-]{36})/")
def heartbeat():
with open(HEARTBEAT, "w") as f:
f.write(str(time.time()))
def _delete(report, key, dry_run):
if dry_run:
return True
try:
OBJ.delete(key)
report["deleted_objects"] += 1
return True
except Exception as exc:
report["errors"] += 1
log.warning("object not deleted (%s)", type(exc).__name__)
return False
def run_once(grace_seconds, dry_run, staging_retention=STAGING_RETENTION):
started = time.monotonic()
report = {"dry_run": dry_run, "grace_seconds": grace_seconds, "staging_retention_seconds": staging_retention,
"abandoned_pending": 0, "staging_ready_cleaned": 0, "staging_failed_expired": 0,
"staging_skipped_changed": 0,
"orphan_objects": 0, "missing_objects": 0, "deleted_objects": 0, "deleted_rows": 0, "errors": 0}
with STORE.pool.connection() as conn:
conn.autocommit = True
if not conn.execute("SELECT pg_try_advisory_lock(%s) AS ok", (JANITOR_LOCK_ID,)).fetchone()["ok"]:
report["skipped"] = "another janitor is running"
return report
try:
now_db = conn.execute("SELECT now() AS t").fetchone()["t"]
cutoff = now_db - dt.timedelta(seconds=grace_seconds)
report["rows_by_status"] = {r["status"]: r["n"] for r in conn.execute(
"SELECT status, count(*) AS n FROM attachments GROUP BY status")}
report["jobs_by_status"] = {r["status"]: r["n"] for r in conn.execute(
"SELECT status, count(*) AS n FROM jobs GROUP BY status")}
report["outbox_unpublished"] = conn.execute(
"SELECT count(*) AS n FROM outbox WHERE published_at IS NULL").fetchone()["n"]
# 1. брошенные pending
abandoned = conn.execute(
"""SELECT id, staging_key FROM attachments
WHERE status = 'pending' AND created_at < %s ORDER BY created_at""", (cutoff,)).fetchall()
report["abandoned_pending"] = len(abandoned)
report["abandoned_ids"] = [str(r["id"]) for r in abandoned[:20]]
for row in abandoned:
if dry_run:
continue
if row["staging_key"] and not _delete(report, row["staging_key"], dry_run):
continue
report["deleted_rows"] += conn.execute(
"DELETE FROM attachments WHERE id = %s AND status = 'pending'", (row["id"],)).rowcount
# 2/3. staging, который больше не нужен
stale = conn.execute(
"""SELECT a.id, a.staging_key, a.status, j.id AS job_id FROM attachments a
LEFT JOIN jobs j ON j.attachment_id = a.id AND j.pipeline_version = a.pipeline_version
WHERE a.staging_key IS NOT NULL AND (a.status = 'ready'
OR (a.status = 'failed' AND a.updated_at < now() - make_interval(secs => %s)))""",
(staging_retention,)).fetchall()
report["staging_candidates"] = [str(r["id"]) for r in stale][:20]
if stale and PAUSE_AFTER_SELECT > 0:
time.sleep(PAUSE_AFTER_SELECT)
for row in stale:
if dry_run:
report["staging_ready_cleaned" if row["status"] == "ready" else "staging_failed_expired"] += 1
continue
# Аудит F01: выборка выше — без блокировок; между ней и удалением оператор мог
# выполнить replay (failed -> queued), и удаление уничтожило бы исходник принятой
# работы. Поэтому под блокировкой строк (порядок как у replay и worker:
# сначала jobs, потом attachments) условие проверяется ЗАНОВО, ссылка
# staging_key снимается и фиксируется, и только ПОСЛЕ COMMIT удаляется объект.
# Replay после этого увидит staging_key IS NULL и откажет (refused_staging_expired);
# replay, успевший раньше, оставит queued — и janitor пропустит строку.
with conn.transaction():
conn.execute("SELECT 1 FROM jobs WHERE attachment_id = %s FOR UPDATE", (row["id"],))
claimed = conn.execute(
"""UPDATE attachments SET staging_key = NULL
WHERE id = %s AND staging_key = %s AND (status = 'ready'
OR (status = 'failed' AND updated_at < now() - make_interval(secs => %s)))
RETURNING status""",
(row["id"], row["staging_key"], staging_retention)).fetchone()
if claimed is None:
report["staging_skipped_changed"] += 1 # состояние изменилось (replay и т. п.)
continue
if row["job_id"]:
jobs.add_event(conn, row["job_id"], "staging_released", None, "janitor",
{"status": claimed["status"]})
report["staging_ready_cleaned" if claimed["status"] == "ready" else "staging_failed_expired"] += 1
# Ссылки уже нет: если удаление не удастся, объект станет сиротой и будет удалён
# обходом bucket после grace — исходник «живой» работы так не потеряется.
_delete(report, row["staging_key"], dry_run)
# 4/5. обход bucket. Момент начала — по часам БД: ready раньше этого момента обязан
# иметь все объекты в листинге (объекты пишутся ДО COMMIT ready).
list_started = conn.execute("SELECT now() AS t").fetchone()["t"]
listed = {}
for prefix in PREFIXES:
for obj in OBJ.client.list_objects(OBJ.bucket, prefix=prefix, recursive=True):
listed[obj.object_name] = obj.last_modified
report["objects_total"] = len(listed)
report["objects_by_prefix"] = {p: sum(1 for k in listed if k.startswith(p)) for p in PREFIXES}
known = set()
busy = set() # вложения с текущей работой: их объекты не трогаем
keys = list(listed)
for i in range(0, len(keys), 1000):
batch = keys[i:i + 1000]
for r in conn.execute(
"""SELECT staging_key AS k FROM attachments WHERE staging_key = ANY(%(b)s)
UNION SELECT object_key FROM attachments WHERE status = 'ready' AND object_key = ANY(%(b)s)
UNION SELECT object_key FROM attachment_variants WHERE object_key = ANY(%(b)s)""",
{"b": batch}):
known.add(r["k"])
ids = {m.group(1) for k in keys for m in [_FINAL_RE.match(k)] if m}
if ids:
for r in conn.execute(
"SELECT id FROM attachments WHERE id = ANY(%s::uuid[]) AND status IN ('pending','queued','processing')",
(list(ids),)):
busy.add(str(r["id"]))
orphans = []
for k, mtime in listed.items():
if k in known or mtime is None or mtime >= cutoff:
continue
m = _FINAL_RE.match(k)
if m and m.group(1) in busy:
continue
orphans.append(k)
report["orphan_objects"] = len(orphans)
report["orphan_keys_sample"] = sorted(orphans)[:5]
for key in orphans:
_delete(report, key, dry_run)
missing = []
for r in conn.execute(
"""SELECT a.id, a.object_key AS k FROM attachments a WHERE a.status = 'ready' AND a.updated_at < %s
UNION ALL
SELECT v.attachment_id, v.object_key FROM attachment_variants v
JOIN attachments a ON a.id = v.attachment_id
WHERE a.status = 'ready' AND a.updated_at < %s""", (list_started, list_started)):
if r["k"] not in listed:
missing.append(str(r["id"]))
report["missing_objects"] = len(missing)
report["missing_ids_sample"] = sorted(set(missing))[:5]
if missing:
log.error("ready attachments without object: %d (manual investigation needed)", len(missing))
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (JANITOR_LOCK_ID,))
report["duration_ms"] = round((time.monotonic() - started) * 1000, 1)
return report
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--once", action="store_true")
parser.add_argument("--dry-run", action="store_true")
parser.add_argument("--grace-seconds", type=int,
default=int(os.environ.get("ATTACHMENT_GRACE_SECONDS", "3600")))
parser.add_argument("--staging-retention-seconds", type=int, default=STAGING_RETENTION)
parser.add_argument("--interval", type=int, default=int(os.environ.get("JANITOR_INTERVAL_SECONDS", "300")))
args = parser.parse_args()
if args.grace_seconds < 1:
parser.error("grace period must be positive")
STORE.open()
try:
while True:
try:
print(json.dumps(run_once(args.grace_seconds, args.dry_run, args.staging_retention_seconds),
ensure_ascii=False), flush=True)
except Exception as exc:
log.warning("janitor pass failed (%s)", type(exc).__name__)
if args.once:
return 1
if args.once:
return 0
wake = time.monotonic() + args.interval
while time.monotonic() < wake:
heartbeat()
time.sleep(min(30, max(0.1, wake - time.monotonic())))
finally:
STORE.close()
if __name__ == "__main__":
sys.exit(main())