Files
mtusi2026lab5/app/janitor.py
T

181 lines
8.9 KiB
Python

"""
Очистка «сирот» после сбоев между S3 и PostgreSQL (lab4, уровень 4).
Протокол загрузки (app/main.py → upload_attachment):
1. INSERT upload_intents(object_key) + COMMIT ← намерение записано
2. PUT объекта в S3
3. BEGIN; DELETE upload_intents …; INSERT attachments …; COMMIT ← 201 только после этого
Если 2 или 3 не удались — API сразу компенсирует (удаляет объект и строку журнала).
Если компенсация не удалась или процесс упал (kill -9, OOM, рестарт контейнера) —
в журнале остаётся строка без метаданных. Её и обрабатывает janitor:
строка upload_intents СТАРШЕ grace period →
BEGIN; DELETE строку (блокировка); DELETE объект в S3; COMMIT
- ошибка S3 → ROLLBACK, строка остаётся, повтор на следующем проходе;
- упали после DELETE в S3, до COMMIT → строка остаётся, повторное
удаление объекта безопасно (DELETE в S3 идемпотентен).
Почему grace period безопасен: живая загрузка не может длиться дольше
UPLOAD_BODY_TIMEOUT_SECONDS (60 c) + таймауты S3/БД (~30 c). По умолчанию
UPLOAD_GRACE_SECONDS = 900 c (15 мин) — в 10 раз больше. Даже если
загрузка «проспала» grace period, шаг 3 удаляет строку журнала в той же
транзакции, что и INSERT метаданных: если janitor уже забрал строку, загрузка
получит 0 строк, откатится и ответит 503 — 201 на удалённый объект невозможен.
Готовые вложения (есть строка в attachments) janitor не трогает никогда.
Страховка (--scan-bucket): обход bucket по prefix originals/ — объект старше
grace period, для которого нет ни attachments, ни upload_intents, — сирота.
Запуск:
- в каждой реплике API фоновым циклом (JANITOR_INTERVAL_SECONDS), но
одновременно работает только одна: pg_try_advisory_lock;
- вручную: python -m app.janitor --once [--dry-run] [--scan-bucket] [--grace-seconds N]
"""
from __future__ import annotations
import argparse
import asyncio
import json
import logging
import random
import time
from datetime import datetime, timedelta, timezone
import psycopg
from fastapi.concurrency import run_in_threadpool
from . import db, storage
from .config import settings
log = logging.getLogger("messenger.janitor")
LOCK_ID = 824_113_2027
BATCH = 500
async def _sweep_intents(conn, grace: int, dry_run: bool, stats: dict) -> None:
cur = await conn.execute(
"SELECT object_key FROM upload_intents "
"WHERE created_at < now() - make_interval(secs => %s) ORDER BY created_at LIMIT %s",
(grace, BATCH))
keys = [r[0] for r in await cur.fetchall()]
for key in keys:
stats["intents_expired"] += 1
try:
async with conn.transaction():
cur = await conn.execute(
"DELETE FROM upload_intents WHERE object_key = %s "
"AND created_at < now() - make_interval(secs => %s) RETURNING 1", (key, grace))
if await cur.fetchone() is None:
continue # загрузка успела завершиться — не наше
cur = await conn.execute("SELECT 1 FROM attachments WHERE object_key = %s", (key,))
committed = await cur.fetchone() is not None
if dry_run:
stats["would_delete_objects"] += 0 if committed else 1
raise psycopg.Rollback()
if not committed:
await storage.delete(key) # ошибка → ROLLBACK, строка останется
stats["objects_deleted"] += 1
stats["intents_removed"] += 1
except storage.StorageUnavailable:
stats["errors"] += 1
log.warning("janitor: s3 unavailable, will retry later")
return
async def _scan_bucket(conn, grace: int, dry_run: bool, stats: dict) -> None:
cutoff = datetime.now(timezone.utc) - timedelta(seconds=grace)
def old_keys() -> list[str]:
# lab5: оригиналы публикует worker в originals/, приём идёт в staging/ — обходим оба.
return [k for prefix in (storage.ORIGINALS_PREFIX, storage.STAGING_PREFIX)
for k, modified, _ in storage.list_sync(prefix) if modified < cutoff]
try:
candidates = await run_in_threadpool(old_keys)
except storage.StorageUnavailable:
stats["errors"] += 1
return
stats["objects_scanned"] = len(candidates)
for i in range(0, len(candidates), BATCH):
part = candidates[i:i + BATCH]
cur = await conn.execute(
"SELECT object_key FROM attachments WHERE object_key = ANY(%s) "
"UNION SELECT staging_key FROM attachments WHERE staging_key = ANY(%s) "
"UNION SELECT object_key FROM upload_intents WHERE object_key = ANY(%s)", (part, part, part))
known = {r[0] for r in await cur.fetchall()}
for key in part:
if key in known:
continue
stats["orphans_found"] += 1
if dry_run:
continue
try:
await storage.delete(key)
stats["objects_deleted"] += 1
except storage.StorageUnavailable:
stats["errors"] += 1
return
async def run_once(grace: int | None = None, dry_run: bool = False,
scan_bucket: bool = False) -> dict:
grace = settings.upload_grace_seconds if grace is None else grace
stats = {"grace_seconds": grace, "dry_run": dry_run, "locked": False,
"intents_expired": 0, "intents_removed": 0, "objects_deleted": 0,
"would_delete_objects": 0, "orphans_found": 0, "errors": 0}
started = time.monotonic()
async with db.get_pool().connection() as conn:
await conn.set_autocommit(True)
cur = await conn.execute("SELECT pg_try_advisory_lock(%s)", (LOCK_ID,))
if not (await cur.fetchone())[0]:
return stats # другая реплика уже чистит
stats["locked"] = True
try:
await _sweep_intents(conn, grace, dry_run, stats)
if scan_bucket:
await _scan_bucket(conn, grace, dry_run, stats)
finally:
await conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,))
await conn.set_autocommit(False)
stats["duration_ms"] = round((time.monotonic() - started) * 1000, 1)
return stats
async def loop_forever() -> None:
"""Фоновый цикл в реплике API. Ошибки логируются, цикл не падает."""
runs = 0
while True:
# Случайный сдвиг: реплики не стучатся в advisory lock одновременно.
await asyncio.sleep(settings.janitor_interval_seconds * random.uniform(0.8, 1.2))
runs += 1
try:
stats = await run_once(scan_bucket=(runs % 60 == 0)) # обход bucket — примерно раз в час
if stats["intents_removed"] or stats["objects_deleted"] or stats["errors"]:
log.info("janitor: %s", stats)
except asyncio.CancelledError:
raise
except Exception as exc: # noqa: BLE001 — фоновая задача не должна умирать
log.warning("janitor run failed: %s", type(exc).__name__)
async def _cli() -> None:
ap = argparse.ArgumentParser(description="cleanup of orphan S3 objects")
ap.add_argument("--once", action="store_true", help="один проход (по умолчанию)")
ap.add_argument("--dry-run", action="store_true", help="только показать, ничего не удалять")
ap.add_argument("--scan-bucket", action="store_true", help="дополнительно обойти bucket")
ap.add_argument("--grace-seconds", type=int, default=None)
args = ap.parse_args()
await db.open_pool()
storage.init()
try:
await db.get_pool().wait(timeout=10)
stats = await run_once(args.grace_seconds, args.dry_run, args.scan_bucket)
finally:
await db.close_pool()
print(json.dumps(stats, ensure_ascii=False))
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
asyncio.run(_cli())