forked from mtusi2026/mtusi2026lab5
181 lines
8.9 KiB
Python
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())
|