Files
mtusi2026lab4/src/reconcile.py
T

238 lines
12 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.
"""Согласованность PostgreSQL (метаданные) и S3 (байты): сборка мусора и сверка.
Почему неучтённых объектов «навсегда» не бывает (подробно — REPORT.md):
загрузка: [1] INSERT attachments(state=pending, object_key) COMMIT
[2] S3 PUT object_key
[3] UPDATE state=ready WHERE state=pending COMMIT -> 201
Ключ объекта записан в БД ДО того, как объект появится в бакете.
Сбой/обрыв между шагами:
после [1] -> строка pending без объекта;
после [2] -> строка pending + объект (S3 прошёл, COMMIT [3] — нет);
ошибка S3 в [2] -> API сам компенсирует: DELETE pending;
ошибка БД в [3] -> API сам компенсирует: DELETE object (pending уберёт GC).
Процесс может умереть в любой точке, поэтому компенсация в запросе —
оптимизация, а гарантию даёт сборщик:
A. stale pending: строки pending старше GRACE. Сначала строка удаляется
(DELETE ... WHERE state='pending' RETURNING object_key — атомарный захват:
если запрос всё-таки успел сделать [3], строка уже ready и не удаляется),
затем удаляется объект. Если удаление объекта не удалось — объект стал
«сиротой» и будет убран проходом B.
B. orphan objects: объекты в бакете (префикс originals/), для ключа которых
в БД нет строки, и LastModified старше GRACE. Строка всегда создаётся
раньше объекта и после удаления не возрождается (ключ одноразовый),
поэтому «нет строки» + «старше GRACE» = объект не принадлежит живой загрузке.
C. missing objects: строки ready без объекта (или с другим размером) — только
отчёт: восстановить байты нельзя, удалять метаданные автоматически опасно.
GRACE (ATTACHMENT_GC_GRACE_SECONDS, по умолчанию 900 с, минимум 300 с) много
больше самой долгой загрузки: чтение тела <= UPLOAD_READ_TIMEOUT_SECONDS (60 с)
+ проверка + S3 PUT (connect 2 с + read 10 с) x S3_MAX_ATTEMPTS (2).
Строки ready и вложения, на которые ссылаются сообщения, сборщик не трогает
никогда (FK message_attachments -> attachments ON DELETE RESTRICT).
CLI (по умолчанию dry-run, ничего не меняет):
python -m src.reconcile # отчёт
python -m src.reconcile --apply # исправить A и B
python -m src.reconcile --apply --grace-seconds 0 # только на учебном стенде
"""
import argparse
import json
import logging
import time
from datetime import datetime, timedelta, timezone
from typing import Dict, List, Optional
from psycopg_pool import ConnectionPool
from .objectstore import ObjectStore, ObjectStoreUnavailable
log = logging.getLogger("messenger.reconcile")
OBJECT_PREFIX = "originals/"
GC_LOCK_ID = 2026_0004
BATCH = 500
def _try_lock(conn) -> bool:
return conn.execute("SELECT pg_try_advisory_lock(%s)", (GC_LOCK_ID,)).fetchone()[0]
def _unlock(conn) -> None:
conn.execute("SELECT pg_advisory_unlock(%s)", (GC_LOCK_ID,))
def collect_stale_pending(pool: ConnectionPool, store: ObjectStore, grace_seconds: int,
apply: bool, report: Dict) -> None:
"""Проход A. dry-run: только подсчёт; apply: строка -> затем объект."""
with pool.connection() as conn:
rows = conn.execute(
"""
SELECT id, object_key FROM attachments
WHERE state = 'pending' AND created_at < clock_timestamp() - make_interval(secs => %s)
ORDER BY created_at LIMIT %s
""",
(grace_seconds, BATCH),
).fetchall()
report["stale_pending"] = len(rows)
report["stale_pending_ids"] = [str(r[0]) for r in rows[:20]]
if not apply:
return
deleted_rows = deleted_objects = 0
for att_id, _key in rows:
with pool.connection() as conn:
claimed = conn.execute(
"""
DELETE FROM attachments
WHERE id = %s AND state = 'pending'
AND created_at < clock_timestamp() - make_interval(secs => %s)
RETURNING object_key
""",
(att_id, grace_seconds),
).fetchone()
if claimed is None:
continue # загрузка успела завершиться (ready) — не трогаем
deleted_rows += 1
try:
store.delete(claimed[0])
deleted_objects += 1
except ObjectStoreUnavailable:
# Объект стал сиротой без строки; его уберёт проход B.
log.warning("gc: object delete deferred to orphan sweep")
report["stale_pending_rows_deleted"] = deleted_rows
report["stale_pending_object_deletes"] = deleted_objects
def sweep_orphans(pool: ConnectionPool, store: ObjectStore, grace_seconds: int,
apply: bool, report: Dict, verify_ready: bool = True) -> None:
"""Проходы B и C: полный обход префикса бакета страницами по 1000."""
cutoff = datetime.now(timezone.utc) - timedelta(seconds=grace_seconds)
token: Optional[str] = None
listed = orphans = orphans_young = deleted = 0
seen_keys: List[str] = []
orphan_sample: List[str] = []
started = time.monotonic()
while True:
items, token = store.list_page(OBJECT_PREFIX, token)
listed += len(items)
if items:
keys = [k for k, _, _ in items]
with pool.connection() as conn:
known = {r[0] for r in conn.execute(
"SELECT object_key FROM attachments WHERE object_key = ANY(%s)", (keys,)
).fetchall()}
for key, modified, _size in items:
if key in known:
if verify_ready:
seen_keys.append(key)
continue
orphans += 1
if modified > cutoff:
orphans_young += 1 # возможно, живая загрузка или ещё не истёк grace
continue
if len(orphan_sample) < 20:
orphan_sample.append(key)
if apply:
# Повторная проверка непосредственно перед удалением.
with pool.connection() as conn:
again = conn.execute(
"SELECT 1 FROM attachments WHERE object_key = %s", (key,)
).fetchone()
if again is None:
store.delete(key)
deleted += 1
if not token:
break
report["objects_listed"] = listed
report["orphan_objects"] = orphans
report["orphan_objects_within_grace"] = orphans_young
report["orphan_objects_sample"] = orphan_sample
if apply:
report["orphan_objects_deleted"] = deleted
report["bucket_scan_seconds"] = round(time.monotonic() - started, 3)
if verify_ready:
# C: ready-строки, для которых объекта нет в листинге (или не тот размер).
present = set(seen_keys)
with pool.connection() as conn:
rows = conn.execute(
"SELECT id, object_key, size_bytes FROM attachments WHERE state = 'ready'"
).fetchall()
missing = [str(r[0]) for r in rows if r[1] not in present]
report["ready_rows"] = len(rows)
report["missing_objects"] = len(missing)
report["missing_object_ids"] = missing[:20]
def run_once(pool: ConnectionPool, store: ObjectStore, grace_seconds: int, apply: bool,
orphan_sweep: bool = True) -> Optional[Dict]:
"""Один проход под advisory lock. None — сейчас работает другая реплика."""
report: Dict = {"mode": "apply" if apply else "dry-run", "grace_seconds": grace_seconds}
with pool.connection() as lock_conn:
lock_conn.autocommit = True
if not _try_lock(lock_conn):
return None
try:
collect_stale_pending(pool, store, grace_seconds, apply, report)
if orphan_sweep:
sweep_orphans(pool, store, grace_seconds, apply, report)
finally:
_unlock(lock_conn)
# Соединение вернётся в общий пул — режим транзакций как у остальных.
lock_conn.autocommit = False
return report
def gc_loop(pool: ConnectionPool, store: ObjectStore, settings, stop) -> None:
"""Фон в каждой реплике: проход A каждые N с, проход B — реже. Lock — одна реплика."""
last_sweep = time.monotonic()
while not stop.wait(settings.attachment_gc_interval_seconds):
try:
sweep = time.monotonic() - last_sweep >= settings.orphan_sweep_interval_seconds
report = run_once(pool, store, settings.attachment_gc_grace_seconds, apply=True,
orphan_sweep=sweep)
if report is None:
continue
if sweep:
last_sweep = time.monotonic()
if report.get("stale_pending") or report.get("orphan_objects_deleted") or report.get("missing_objects"):
log.info("attachment gc: %s", json.dumps(report, ensure_ascii=False))
except Exception as exc: # БД/S3 недоступны — следующий проход повторит
log.warning("attachment gc skipped: %s", type(exc).__name__)
def main() -> None:
parser = argparse.ArgumentParser(description="Reconcile attachments metadata (PostgreSQL) with S3 objects")
parser.add_argument("--apply", action="store_true", help="delete stale pending rows and orphan objects")
parser.add_argument("--grace-seconds", type=int, default=None,
help="override ATTACHMENT_GC_GRACE_SECONDS (values < 300 only for lab tests)")
parser.add_argument("--no-orphan-sweep", action="store_true", help="skip bucket listing")
args = parser.parse_args()
logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s %(message)s")
from .config import load_settings
from .db import create_pool
settings = load_settings()
if not ObjectStore.configured(settings):
raise SystemExit("S3 is not configured")
grace = settings.attachment_gc_grace_seconds if args.grace_seconds is None else args.grace_seconds
pool = create_pool(settings)
pool.wait(timeout=15)
store = ObjectStore(settings)
try:
started = time.monotonic()
report = run_once(pool, store, grace, args.apply, orphan_sweep=not args.no_orphan_sweep)
if report is None:
raise SystemExit("another reconciler holds the lock; retry later")
report["total_seconds"] = round(time.monotonic() - started, 3)
print(json.dumps(report, ensure_ascii=False, indent=2))
finally:
pool.close()
if __name__ == "__main__":
main()