forked from mtusi2026/mtusi2026lab3
143 lines
9.8 KiB
Python
143 lines
9.8 KiB
Python
"""Таблицы замеров для REPORT.md из evidence/*.json (без ручного переписывания чисел).
|
||
|
||
make report-tables (= python student-tests/report_tables.py)
|
||
|
||
Берёт evidence/failover-metrics.json, rolling-update.json, load.json, load-stats.json
|
||
и время из evidence/persistence.txt, собирает markdown-таблицы и вставляет их в REPORT.md
|
||
между метками <!-- measurements:begin --> и <!-- measurements:end -->. Запускать после
|
||
make failover-metrics, make rolling-update, make load-profile и make persistence.
|
||
"""
|
||
import json
|
||
import re
|
||
|
||
from helpers import ROOT, check, run
|
||
|
||
EVIDENCE = ROOT / "evidence"
|
||
REPORT = ROOT / "REPORT.md"
|
||
BEGIN, END = "<!-- measurements:begin -->", "<!-- measurements:end -->"
|
||
|
||
|
||
def load(name):
|
||
path = EVIDENCE / name
|
||
return json.loads(path.read_text(encoding="utf-8")) if path.exists() else None
|
||
|
||
|
||
def codes(mapping):
|
||
return ", ".join(f"{code}: {count}" for code, count in mapping.items()) or "-"
|
||
|
||
|
||
def failover_table(data):
|
||
lines = [
|
||
f"Остановка каждой реплики под нагрузкой (`make failover-metrics`, evidence/failover-metrics.json): "
|
||
f"{data['profile']['writers']} потока пишут сообщения без пауз, 1 читает историю, timeout клиента "
|
||
f"{data['profile']['client_timeout_seconds']} с, неподтверждённая запись повторяется с тем же ключом; "
|
||
f"{data['profile']['warmup_seconds']} с до отказа и {data['profile']['after_seconds']} с после. "
|
||
"stop = `docker stop` (SIGTERM, плановая остановка), kill = `docker kill` (SIGKILL, авария).",
|
||
"",
|
||
"| Реплика | Отказ | Вывод из LB, с | Ошибок (коды) | Ошибки закончились через, с | Записей/с до → после | "
|
||
"p95 записи после, мс | Возврат в LB после `docker start`, с | Потери / дубли |",
|
||
"| --- | --- | --- | --- | --- | --- | --- | --- | --- |",
|
||
]
|
||
for r in data["runs"]:
|
||
lines.append(f"| {r['replica']} | {r['mode']} | {r['lb_excluded_after_seconds']} | {r['errors']} "
|
||
f"({codes(r['error_codes'])}) | {r['errors_stopped_after_seconds']} | "
|
||
f"{r['before']['write_rps']} → {r['after']['write_rps']} | {r['after']['write_p95_ms']} | "
|
||
f"{r['rejoin_seconds']} | 0 / 0 (подтверждено {r['integrity']['confirmed_writes']}) |")
|
||
return lines
|
||
|
||
|
||
def rolling_lines(data):
|
||
during = data["during"]
|
||
steps = "; ".join(f"{s['old']} → {s['new']}: новая готова через {s['new_ready_seconds']} с, шаг {s['step_seconds']} с"
|
||
for s in data["steps"])
|
||
return [f"Rolling update под той же нагрузкой (`make rolling-update`, evidence/rolling-update.json): версия "
|
||
f"{data['from_version']} → {data['to_version']}, {data['replicas']} реплики заменены по одной за "
|
||
f"{data['update_seconds']} с ({steps}). Записей/с до: {data['before']['write_rps']}, во время замены: "
|
||
f"{during['write_rps']}; ошибок: {during['errors']} ({codes(during['error_codes'])}); p95 "
|
||
f"{during['write_p95_ms']} мс, максимум {during['write_max_ms']} мс; подтверждено "
|
||
f"{data['integrity']['confirmed_writes']} сообщений, потерь и дублей нет."]
|
||
|
||
|
||
def load_lines(data, stats):
|
||
latency = data["successful_latency_ms"]
|
||
lines = [f"Публичный генератор нагрузки (`make load-profile` = `tests/load.py`, closed loop, {data['concurrency']} "
|
||
f"потока, {data['requested_duration_seconds']:.0f} с, 2 реплики): {data['successful_rps']} успешных "
|
||
f"POST/с, ошибок {data['failed_requests']} (доля {data['error_ratio']}), задержка успешных: p50 "
|
||
f"{latency['p50']} мс, p95 {latency['p95']} мс, p99 {latency['p99']} мс."]
|
||
if stats:
|
||
lines += ["", "| Сервис | CPU, % макс. (100 % = 1 ядро) | RAM макс. / лимит, МиБ |", "| --- | --- | --- |"]
|
||
lines += [f"| {row['service']} | {row['cpu_percent_max']:.1f} | {row['mem_mib_max']:.0f} / {row['mem_limit_mib']} |"
|
||
for row in stats["containers"]]
|
||
return lines
|
||
|
||
|
||
def impacts(failover, rolling):
|
||
rows = ["| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |",
|
||
"| --- | --- | --- | --- |"]
|
||
if failover:
|
||
for mode, title, expect in (
|
||
("stop", "`docker stop` одной реплики (по очереди каждой)",
|
||
"реплика сама уходит из балансировки до выхода; ошибок нет"),
|
||
("kill", "`docker kill` одной реплики (по очереди каждой)",
|
||
"несколько 502 у запросов, начатых на ней; клиент повторяет с тем же ключом")):
|
||
runs = [r for r in failover["runs"] if r["mode"] == mode]
|
||
if not runs:
|
||
continue
|
||
errors = sum(r["errors"] for r in runs)
|
||
out = max(r["lb_excluded_after_seconds"] or 0 for r in runs)
|
||
end = max(r["errors_stopped_after_seconds"] for r in runs)
|
||
recovery = f"ошибки закончились не позже {end} с после отказа" if errors else "ошибок не было"
|
||
rows.append(f"| {title} | {expect} | ошибок всего {errors} за {len(runs)} прогона; HAProxy вывел реплику "
|
||
f"не позже {out} с; остановленная реплика после остановки не отвечала | {recovery}; "
|
||
f"потерь и дублей 0 |")
|
||
if rolling:
|
||
rows.append(f"| Rolling update 2 реплик под нагрузкой | замена по одной без простоя | ошибок "
|
||
f"{rolling['during']['errors']}, записей/с {rolling['during']['write_rps']} | "
|
||
f"{rolling['update_seconds']} с на замену; потерь и дублей 0 |")
|
||
persistence = EVIDENCE / "persistence.txt"
|
||
if persistence.exists():
|
||
found = re.search(r"test took ([\d.]+) s", persistence.read_text(encoding="utf-8"))
|
||
if found:
|
||
rows.append(f"| Перезапуск всего стенда (`make persistence`, hook restart) | данные и действующий токен "
|
||
f"сохраняются | PASS: те же контейнеры с новым временем старта, прежний токен работает | "
|
||
f"{found.group(1)} с на весь тест (hook + готовность); потерь нет |")
|
||
# Отказы зависимостей (проверки lab2, теперь через балансировщик): строка — если тест прошёл.
|
||
for name, title, expect, seen, recovery in (
|
||
("failure-valkey.txt", "`docker compose stop valkey`", "API работает без кэша",
|
||
"ready 200; вход, сообщения и logout работают через PostgreSQL",
|
||
"кэш снова включается за 1–2 с после start; потерь нет"),
|
||
("failure-postgres.txt", "`docker compose stop postgres`",
|
||
"неготовые реплики исключены из маршрутизации, клиенту 503",
|
||
"HAProxy вывел обе реплики (ready 503, live 200); запрос с действующим токеном из кэша -> 503 "
|
||
"от балансировщика, до реплики не дошёл; запись не сохранилась",
|
||
"после start прежний токен и данные на месте; запросы во время отказа не сохранены (503)"),
|
||
("failure-valkey-pause.txt", "`docker compose pause valkey`, logout, `unpause`",
|
||
"отозванный токен не оживает ни на одной реплике", "после unpause отозванный токен всегда 401",
|
||
"поколение кэша сменилось после возвращения Valkey; отзыв не потерян")):
|
||
path = EVIDENCE / name
|
||
if path.exists() and "PASS" in path.read_text(encoding="utf-8"):
|
||
rows.append(f"| {title} | {expect} | {seen} | {recovery} |")
|
||
return rows if len(rows) > 2 else []
|
||
|
||
|
||
def main():
|
||
failover, rolling = load("failover-metrics.json"), load("rolling-update.json")
|
||
load_result, stats = load("load.json"), load("load-stats.json")
|
||
parts = []
|
||
for block in (failover and failover_table(failover), rolling and rolling_lines(rolling),
|
||
load_result and load_lines(load_result, stats), impacts(failover, rolling)):
|
||
if block:
|
||
parts += block + [""]
|
||
check(parts, "no evidence/*.json yet: run make failover-metrics, rolling-update, load-profile first")
|
||
text = REPORT.read_text(encoding="utf-8")
|
||
check(BEGIN in text and END in text, "REPORT.md has no measurements markers")
|
||
head, rest = text.split(BEGIN, 1)
|
||
_, tail = rest.split(END, 1)
|
||
REPORT.write_text(head + BEGIN + "\n" + "\n".join(parts).strip() + "\n" + END + tail, encoding="utf-8")
|
||
print("\n".join(parts).strip())
|
||
print("\nPASS: tables inserted into REPORT.md between the measurements markers")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
run(main)
|