Files
mtusi2026lab7/src/janitor.py
T
zemiles 9cc80d2529
Application / app (pull_request) Canceled after 0s
Skeleton contracts / contracts (pull_request) Canceled after 0s
ЛР 7 — БПИ2303 — Лазарев — на 3
Перенесена реализация 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.
2026-11-18 23:59:35 +03:00

243 lines
14 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.
#!/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())