Лабораторная работа 6

This commit is contained in:
2026-11-13 01:27:57 +03:00
parent 470d9d6f1e
commit 2dbdcf898c
218 changed files with 22057 additions and 37 deletions
+295
View File
@@ -0,0 +1,295 @@
"""Согласованность PostgreSQL (метаданные) и S3 (байты): сборка мусора и сверка.
lab5: префиксы бакета
staging/<hex> — принятый оригинал до обработки (API);
final/<id>/original — опубликованный оригинал (worker);
final/<id>/p<версия>/<вариант>.<ext> — варианты (worker);
originals/<hex> — оригиналы lab4 (до перехода на lab5).
Строка pending ссылается на staging_key (объект появляется ПОСЛЕ строки).
Добавлен проход D — очистка staging: ready-вложения (staging больше не нужен,
результат опубликован) и failed старше STAGING_RETENTION_SECONDS (после этого
replay невозможен — нужен повторный upload). Текущую работу (queued/processing)
сборщик не трогает никогда.
Почему неучтённых объектов «навсегда» не бывает (подробно — 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/" # lab4
STAGING_PREFIX = "staging/"
FINAL_PREFIX = "final/"
SCANNED_PREFIXES = (STAGING_PREFIX, FINAL_PREFIX, OBJECT_PREFIX)
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, COALESCE(staging_key, 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 COALESCE(staging_key, 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 known_keys(pool: ConnectionPool, keys: List[str]) -> set:
"""Ключи, на которые ссылается БД: оригинал, staging или вариант."""
with pool.connection() as conn:
rows = 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 attachment_variants WHERE object_key = ANY(%s)
""",
(keys, keys, keys),
).fetchall()
return {r[0] for r in rows}
def clean_staging(pool: ConnectionPool, store: ObjectStore, retention_seconds: int,
apply: bool, report: Dict) -> None:
"""Проход D: staging, который больше не нужен. Строка обновляется ПОСЛЕ удаления
объекта; сбой между шагами безопасен (повторное удаление отсутствующего — no-op)."""
with pool.connection() as conn:
rows = conn.execute(
"""
SELECT id, staging_key, state FROM attachments
WHERE staging_key IS NOT NULL
AND (state = 'ready'
OR (state = 'failed' AND updated_at < clock_timestamp() - make_interval(secs => %s)))
ORDER BY updated_at LIMIT %s
""",
(retention_seconds, BATCH),
).fetchall()
report["staging_to_clean"] = len(rows)
if not apply:
return
cleaned = 0
for att_id, key, state in rows:
try:
store.delete(key)
except ObjectStoreUnavailable:
log.warning("gc: staging delete deferred")
break
with pool.connection() as conn:
conn.execute("UPDATE attachments SET staging_key = NULL WHERE id = %s AND staging_key = %s "
"AND state = %s", (att_id, key, state))
cleaned += 1
report["staging_cleaned"] = cleaned
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()
for prefix in SCANNED_PREFIXES:
token = None
while True:
items, token = store.list_page(prefix, token)
listed += len(items)
if items:
keys = [k for k, _, _ in items]
known = known_keys(pool, keys)
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 and not known_keys(pool, [key]):
# Повторная проверка непосредственно перед удалением.
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' "
"UNION ALL SELECT attachment_id, object_key, size_bytes FROM attachment_variants"
).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, staging_retention_seconds: int = 86400) -> 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)
clean_staging(pool, store, staging_retention_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, staging_retention_seconds=settings.staging_retention_seconds)
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") \
or report.get("staging_cleaned"):
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,
staging_retention_seconds=settings.staging_retention_seconds)
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()