238 lines
12 KiB
Python
238 lines
12 KiB
Python
"""Согласованность 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()
|