Перенесена реализация lab6; бизнес-API без изменений, транспорт — HTTPS. - Внешний HTTPS (public-ca) на 127.0.0.1:8443; HSTS, TLS >= 1.2. - Обязательное mTLS LB -> каждая API-реплика: API проверяет цепочку internal-ca и SAN клиента (allowlist: lb); health только на 127.0.0.1. - TLS с проверкой сервера ко всем зависимостям: PostgreSQL verify-full (pg_hba только hostssl), HTTPS S3, AMQPS, OTLP/HTTPS с client cert, mTLS Collector -> Prometheus/Loki/Tempo, Grafana -> datasources, scrape. - OpenBao 2.7.2 не в dev-mode: Raft на volume, init/unseal оператором, auth/cert с ролью и policy на сервис, TTL 15 мин + renew/re-login. - Отдельные роли PostgreSQL с грантами по таблицам; разные ключи S3 и пользователи брокера выдаются из OpenBao. - Argon2id (m=19 MiB, t=2, p=1, замер на стенде) и rehash при входе. - Случайный X-Instance-Id; hardening контейнеров (non-root, cap_drop ALL, no-new-privileges, read-only, лимиты); TCP_NODELAY на сокете API. - Модель угроз, trust matrix, отрицательные тесты TLS/mTLS, API, OpenBao, hardening; evidence, в т.ч. прогон из чистого clone.
243 lines
14 KiB
Python
243 lines
14 KiB
Python
#!/usr/bin/env python3
|
||
"""Сверка PostgreSQL <-> S3 и очистка (compose-сервис `janitor`). Lab5.
|
||
|
||
Prefix-ы bucket:
|
||
staging/<uuid> принятые оригиналы до публикации результата (attachments.staging_key);
|
||
attachments/<id>/v<ver>/<name> конечные объекты: original и варианты;
|
||
originals/<uuid> оригиналы lab4 (после миграции 004 — staging-объекты backfill-заданий);
|
||
health/, bootstrap/ служебные, не трогаются.
|
||
|
||
За один проход (под pg_try_advisory_lock):
|
||
1. abandoned: pending-строки старше grace (API упал до постановки в очередь, 202 не было)
|
||
-> удалить staging-объект, затем строку;
|
||
2. staging ready: у ready-вложения остался staging (worker не смог удалить после COMMIT)
|
||
-> удалить объект, staging_key = NULL;
|
||
3. staging failed: failed дольше STAGING_RETENTION_SECONDS -> удалить staging (replay после
|
||
этого невозможен: ops replay ответит refused_staging_expired). Для 2 и 3: под блокировкой
|
||
jobs+attachments условие проверяется заново, staging_key снимается и COMMIT, потом DELETE
|
||
в S3 — гонка с replay исключена (аудит F01);
|
||
4. orphan: объекты staging/, originals/, attachments/ старше grace, на которые не ссылается
|
||
ни одна строка (staging_key, object_key ready-вложения, attachment_variants), и вложение
|
||
не queued/processing -> удалить;
|
||
5. missing: ready без объекта оригинала или варианта -> ТОЛЬКО отчёт.
|
||
Текущую работу (queued/processing) janitor не удаляет никогда: её staging нужен worker.
|
||
Grace (ATTACHMENT_GRACE_SECONDS, 3600 с) многократно больше UPLOAD_TIMEOUT_SECONDS и
|
||
JOB_TIMEOUT_SECONDS, поэтому идущая загрузка/обработка не считается брошенной.
|
||
|
||
python src/janitor.py --once --dry-run | --once | --interval 300
|
||
"""
|
||
import argparse
|
||
import datetime as dt
|
||
import json
|
||
import logging
|
||
import os
|
||
import re
|
||
import sys
|
||
import time
|
||
|
||
import jobs
|
||
import telemetry
|
||
from server import OBJ, STORE
|
||
|
||
log = logging.getLogger("messenger.janitor")
|
||
JANITOR_LOCK_ID = 727002
|
||
PREFIXES = ("staging/", "originals/", "attachments/")
|
||
HEARTBEAT = "/tmp/janitor.heartbeat"
|
||
STAGING_RETENTION = int(os.environ.get("STAGING_RETENTION_SECONDS", "86400"))
|
||
# Только для теста гонки (student-tests/janitor_replay_race.py): пауза между выборкой
|
||
# кандидатов и их захватом — воспроизводит чередование «выбрал -> replay -> удаляю». Обычно 0.
|
||
PAUSE_AFTER_SELECT = float(os.environ.get("JANITOR_PAUSE_AFTER_SELECT_SECONDS", "0"))
|
||
_FINAL_RE = re.compile(r"^attachments/([0-9a-f-]{36})/")
|
||
|
||
|
||
def heartbeat():
|
||
with open(HEARTBEAT, "w") as f:
|
||
f.write(str(time.time()))
|
||
|
||
|
||
def _delete(report, key, dry_run):
|
||
if dry_run:
|
||
return True
|
||
try:
|
||
OBJ.delete(key)
|
||
report["deleted_objects"] += 1
|
||
return True
|
||
except Exception as exc:
|
||
report["errors"] += 1
|
||
log.warning("object not deleted (%s)", type(exc).__name__)
|
||
return False
|
||
|
||
|
||
def run_once(grace_seconds, dry_run, staging_retention=STAGING_RETENTION):
|
||
started = time.monotonic()
|
||
report = {"dry_run": dry_run, "grace_seconds": grace_seconds, "staging_retention_seconds": staging_retention,
|
||
"abandoned_pending": 0, "staging_ready_cleaned": 0, "staging_failed_expired": 0,
|
||
"staging_skipped_changed": 0,
|
||
"orphan_objects": 0, "missing_objects": 0, "deleted_objects": 0, "deleted_rows": 0, "errors": 0}
|
||
with STORE.pool.connection() as conn:
|
||
conn.autocommit = True
|
||
if not conn.execute("SELECT pg_try_advisory_lock(%s) AS ok", (JANITOR_LOCK_ID,)).fetchone()["ok"]:
|
||
report["skipped"] = "another janitor is running"
|
||
return report
|
||
try:
|
||
now_db = conn.execute("SELECT now() AS t").fetchone()["t"]
|
||
cutoff = now_db - dt.timedelta(seconds=grace_seconds)
|
||
report["rows_by_status"] = {r["status"]: r["n"] for r in conn.execute(
|
||
"SELECT status, count(*) AS n FROM attachments GROUP BY status")}
|
||
report["jobs_by_status"] = {r["status"]: r["n"] for r in conn.execute(
|
||
"SELECT status, count(*) AS n FROM jobs GROUP BY status")}
|
||
report["outbox_unpublished"] = conn.execute(
|
||
"SELECT count(*) AS n FROM outbox WHERE published_at IS NULL").fetchone()["n"]
|
||
|
||
# 1. брошенные pending
|
||
abandoned = conn.execute(
|
||
"""SELECT id, staging_key FROM attachments
|
||
WHERE status = 'pending' AND created_at < %s ORDER BY created_at""", (cutoff,)).fetchall()
|
||
report["abandoned_pending"] = len(abandoned)
|
||
report["abandoned_ids"] = [str(r["id"]) for r in abandoned[:20]]
|
||
for row in abandoned:
|
||
if dry_run:
|
||
continue
|
||
if row["staging_key"] and not _delete(report, row["staging_key"], dry_run):
|
||
continue
|
||
report["deleted_rows"] += conn.execute(
|
||
"DELETE FROM attachments WHERE id = %s AND status = 'pending'", (row["id"],)).rowcount
|
||
|
||
# 2/3. staging, который больше не нужен
|
||
stale = conn.execute(
|
||
"""SELECT a.id, a.staging_key, a.status, j.id AS job_id FROM attachments a
|
||
LEFT JOIN jobs j ON j.attachment_id = a.id AND j.pipeline_version = a.pipeline_version
|
||
WHERE a.staging_key IS NOT NULL AND (a.status = 'ready'
|
||
OR (a.status = 'failed' AND a.updated_at < now() - make_interval(secs => %s)))""",
|
||
(staging_retention,)).fetchall()
|
||
report["staging_candidates"] = [str(r["id"]) for r in stale][:20]
|
||
if stale and PAUSE_AFTER_SELECT > 0:
|
||
time.sleep(PAUSE_AFTER_SELECT)
|
||
for row in stale:
|
||
if dry_run:
|
||
report["staging_ready_cleaned" if row["status"] == "ready" else "staging_failed_expired"] += 1
|
||
continue
|
||
# Аудит F01: выборка выше — без блокировок; между ней и удалением оператор мог
|
||
# выполнить replay (failed -> queued), и удаление уничтожило бы исходник принятой
|
||
# работы. Поэтому под блокировкой строк (порядок как у replay и worker:
|
||
# сначала jobs, потом attachments) условие проверяется ЗАНОВО, ссылка
|
||
# staging_key снимается и фиксируется, и только ПОСЛЕ COMMIT удаляется объект.
|
||
# Replay после этого увидит staging_key IS NULL и откажет (refused_staging_expired);
|
||
# replay, успевший раньше, оставит queued — и janitor пропустит строку.
|
||
with conn.transaction():
|
||
conn.execute("SELECT 1 FROM jobs WHERE attachment_id = %s FOR UPDATE", (row["id"],))
|
||
claimed = conn.execute(
|
||
"""UPDATE attachments SET staging_key = NULL
|
||
WHERE id = %s AND staging_key = %s AND (status = 'ready'
|
||
OR (status = 'failed' AND updated_at < now() - make_interval(secs => %s)))
|
||
RETURNING status""",
|
||
(row["id"], row["staging_key"], staging_retention)).fetchone()
|
||
if claimed is None:
|
||
report["staging_skipped_changed"] += 1 # состояние изменилось (replay и т. п.)
|
||
continue
|
||
if row["job_id"]:
|
||
jobs.add_event(conn, row["job_id"], "staging_released", None, "janitor",
|
||
{"status": claimed["status"]})
|
||
report["staging_ready_cleaned" if claimed["status"] == "ready" else "staging_failed_expired"] += 1
|
||
# Ссылки уже нет: если удаление не удастся, объект станет сиротой и будет удалён
|
||
# обходом bucket после grace — исходник «живой» работы так не потеряется.
|
||
_delete(report, row["staging_key"], dry_run)
|
||
|
||
# 4/5. обход bucket. Момент начала — по часам БД: ready раньше этого момента обязан
|
||
# иметь все объекты в листинге (объекты пишутся ДО COMMIT ready).
|
||
list_started = conn.execute("SELECT now() AS t").fetchone()["t"]
|
||
listed = {}
|
||
for prefix in PREFIXES:
|
||
for obj in OBJ.client.list_objects(OBJ.bucket, prefix=prefix, recursive=True):
|
||
listed[obj.object_name] = obj.last_modified
|
||
report["objects_total"] = len(listed)
|
||
report["objects_by_prefix"] = {p: sum(1 for k in listed if k.startswith(p)) for p in PREFIXES}
|
||
known = set()
|
||
busy = set() # вложения с текущей работой: их объекты не трогаем
|
||
keys = list(listed)
|
||
for i in range(0, len(keys), 1000):
|
||
batch = keys[i:i + 1000]
|
||
for r in conn.execute(
|
||
"""SELECT staging_key AS k FROM attachments WHERE staging_key = ANY(%(b)s)
|
||
UNION SELECT object_key FROM attachments WHERE status = 'ready' AND object_key = ANY(%(b)s)
|
||
UNION SELECT object_key FROM attachment_variants WHERE object_key = ANY(%(b)s)""",
|
||
{"b": batch}):
|
||
known.add(r["k"])
|
||
ids = {m.group(1) for k in keys for m in [_FINAL_RE.match(k)] if m}
|
||
if ids:
|
||
for r in conn.execute(
|
||
"SELECT id FROM attachments WHERE id = ANY(%s::uuid[]) AND status IN ('pending','queued','processing')",
|
||
(list(ids),)):
|
||
busy.add(str(r["id"]))
|
||
orphans = []
|
||
for k, mtime in listed.items():
|
||
if k in known or mtime is None or mtime >= cutoff:
|
||
continue
|
||
m = _FINAL_RE.match(k)
|
||
if m and m.group(1) in busy:
|
||
continue
|
||
orphans.append(k)
|
||
report["orphan_objects"] = len(orphans)
|
||
report["orphan_keys_sample"] = sorted(orphans)[:5]
|
||
for key in orphans:
|
||
_delete(report, key, dry_run)
|
||
|
||
missing = []
|
||
for r in conn.execute(
|
||
"""SELECT a.id, a.object_key AS k FROM attachments a WHERE a.status = 'ready' AND a.updated_at < %s
|
||
UNION ALL
|
||
SELECT v.attachment_id, v.object_key FROM attachment_variants v
|
||
JOIN attachments a ON a.id = v.attachment_id
|
||
WHERE a.status = 'ready' AND a.updated_at < %s""", (list_started, list_started)):
|
||
if r["k"] not in listed:
|
||
missing.append(str(r["id"]))
|
||
report["missing_objects"] = len(missing)
|
||
report["missing_ids_sample"] = sorted(set(missing))[:5]
|
||
if missing:
|
||
log.error("ready attachments without object: %d (manual investigation needed)", len(missing))
|
||
finally:
|
||
conn.execute("SELECT pg_advisory_unlock(%s)", (JANITOR_LOCK_ID,))
|
||
report["duration_ms"] = round((time.monotonic() - started) * 1000, 1)
|
||
return report
|
||
|
||
|
||
def main():
|
||
parser = argparse.ArgumentParser()
|
||
parser.add_argument("--once", action="store_true")
|
||
parser.add_argument("--dry-run", action="store_true")
|
||
parser.add_argument("--grace-seconds", type=int,
|
||
default=int(os.environ.get("ATTACHMENT_GRACE_SECONDS", "3600")))
|
||
parser.add_argument("--staging-retention-seconds", type=int, default=STAGING_RETENTION)
|
||
parser.add_argument("--interval", type=int, default=int(os.environ.get("JANITOR_INTERVAL_SECONDS", "300")))
|
||
args = parser.parse_args()
|
||
if args.grace_seconds < 1:
|
||
parser.error("grace period must be positive")
|
||
if args.once:
|
||
telemetry.configure_logging(stream=sys.stderr) # stdout — JSON-отчёт для оператора
|
||
else:
|
||
telemetry.setup("messenger-janitor")
|
||
telemetry.observe_pool(STORE.pool, "janitor")
|
||
STORE.open()
|
||
try:
|
||
while True:
|
||
try:
|
||
print(json.dumps(run_once(args.grace_seconds, args.dry_run, args.staging_retention_seconds),
|
||
ensure_ascii=False), flush=True)
|
||
except Exception as exc:
|
||
log.warning("janitor pass failed (%s)", type(exc).__name__,
|
||
extra={"event": "janitor.failed", "error.type": type(exc).__name__})
|
||
if args.once:
|
||
return 1
|
||
if args.once:
|
||
return 0
|
||
wake = time.monotonic() + args.interval
|
||
while time.monotonic() < wake:
|
||
heartbeat()
|
||
time.sleep(min(30, max(0.1, wake - time.monotonic())))
|
||
finally:
|
||
STORE.close()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|