Files
mtusi2026lab5/student-tests/failover_bench.py
T
zemiles 13bec4ab8b ЛР 5 — БПИ2303 — Лазарев — на 4
Асинхронная обработка вложений: RabbitMQ 4.1 (quorum-очереди, publisher
confirms, manual ack, DLQ), transactional outbox, отдельный worker.

- upload: оригинал в staging S3, затем одной транзакцией queued + jobs +
  outbox -> 202; API к брокеру не подключается
- relay: публикация outbox с confirm, reaper истёкших аренд, redrive
- worker: claim по строке jobs, аренда с heartbeat и fencing по
  lease_token, transform в подпроцессе с RLIMIT_AS/RLIMIT_CPU/таймаутом,
  thumbnail 256, crop 128, WebP 1280 по детерминированным ключам
- retry с backoff и jitter, постоянные/временные ошибки, реестр failed,
  ops replay (ready не повторяется), DLQ для невалидных сообщений
- janitor: очистка staging и сирот; миграция 004 с backfill вложений lab4
- тесты отказов: окна COMMIT/publish, крахи worker до/после S3 и ack,
  заморозка worker, всплеск загрузок, права брокера; evidence/ и REPORT.md
2026-11-13 16:28:18 +03:00

265 lines
13 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
"""Отказ/замена API-реплики ПОД НАГРУЗКОЙ: RPS, ошибки, время обнаружения и восстановления (lab3, уровень 4).
Что делает:
* CONCURRENCY потоков в closed-loop шлют смесь запросов через LB: POST сообщения
(с Idempotency-Key) и GET истории (limit=20) в пропорции 1:1;
* после неуспешного/неопределённого POST поток повторяет ТОТ ЖЕ ключ и тело (как
требует контракт), поэтому подтверждённых дублей быть не должно;
* на секунде --action-at запускается --action (например, docker stop/kill контейнера
или scripts/rolling-update.sh), его stdout/stderr пишутся в отдельный лог;
* параллельно каждые 200 мс опрашивается CSV статистики HAProxy: фиксируются моменты
UP -> DOWN / DOWN -> UP серверов backend (время обнаружения отказа LB);
* в конце читается вся история чата (тем же токеном) и проверяется: все подтверждённые
сообщения на месте, дублей нет.
Метрики (все времена — от старта action):
errors_total / error_rate — неуспешные попытки (HTTP != ожидаемого, timeout, разрыв);
error_window_s — от первой до последней ошибки после старта action;
recovery_s — конец окна ошибок (дальше все запросы успешны), 0 если ошибок нет;
post_action_ok_rps/capacity_ratio — успешный RPS после действия и его доля от базового;
lb_down_detected_s — когда HAProxy пометил сервер DOWN;
target_last_seen_s — последний ответ от остановленной реплики.
Ограничения: closed-loop генератор (coordinated omission), клиент на том же хосте, что и
стенд; цифры RPS сравнимы только между прогонами этого же скрипта на этом же ноутбуке.
"""
import argparse
import csv
import io
import json
import shlex
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.request
import uuid
from collections import Counter, defaultdict
from pathlib import Path
from urllib.parse import quote
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
from client import Client # noqa: E402
TIMEOUT = 2.0
def percentile(values, p):
if not values:
return None
s = sorted(values)
return round(s[min(len(s) - 1, int(round(p / 100 * (len(s) - 1))))] * 1000, 1)
class Bench:
def __init__(self, a):
self.a = a
self.base = a.base_url.rstrip("/")
self.lock = threading.Lock()
self.t0 = None
self.stop = threading.Event()
self.per_sec = defaultdict(lambda: {"ok": 0, "err": 0, "inst": Counter(), "ver": Counter()})
self.errors = [] # (t, kind)
self.lat = [] # успешные задержки, с
self.confirmed = {} # message id -> text
self.retried_posts = 0
self.lb_events = []
self.inst_last_seen = {}
def now(self):
return time.monotonic() - self.t0
def record(self, ok, dt, inst=None, ver=None, kind=None):
t = self.now()
with self.lock:
b = self.per_sec[int(t)]
if ok:
b["ok"] += 1
self.lat.append(dt)
if inst:
b["inst"][inst] += 1
self.inst_last_seen[inst] = t
if ver:
b["ver"][ver] += 1
else:
b["err"] += 1
self.errors.append((round(t, 3), kind))
def request(self, method, path, body=None, headers=None, expected=200):
h = {"Authorization": "Bearer " + self.token}
h.update(headers or {})
data = None
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
req = urllib.request.Request(self.base + path, data=data, method=method, headers=h)
start = time.monotonic()
try:
with urllib.request.urlopen(req, timeout=TIMEOUT) as r:
payload = json.loads(r.read())
ok = r.status == expected
self.record(ok, time.monotonic() - start, r.headers.get("X-Instance-Id"),
r.headers.get("X-App-Version"), None if ok else "http_%d" % r.status)
return payload if ok else None
except urllib.error.HTTPError as e:
self.record(False, 0, kind="http_%d" % e.code)
except Exception as e: # noqa: BLE001
self.record(False, 0, kind=type(e).__name__)
return None
def worker(self, n):
chat_path = "/api/v1/chats/" + self.chat["id"] + "/messages"
key = text = None
i = 0
while not self.stop.is_set():
i += 1
if i % 2:
if key is None: # новый логический запрос; после ошибки ключ НЕ меняется
key = "bench-%d-%s" % (n, uuid.uuid4().hex)
text = "Нагрузка " + key
else:
with self.lock:
self.retried_posts += 1
msg = self.request("POST", chat_path, {"text": text}, {"Idempotency-Key": key}, 201)
if msg is not None:
with self.lock:
self.confirmed[msg["id"]] = msg["text"]
key = None
else:
self.request("GET", chat_path + "?limit=20")
def poll_lb(self):
prev = {}
while not self.stop.is_set():
try:
with urllib.request.urlopen(self.a.stats_url, timeout=1) as r:
rows = list(csv.reader(io.StringIO(r.read().decode().lstrip("# "))))
head = rows[0]
ix = {k: head.index(k) for k in ("pxname", "svname", "status", "addr")}
for row in rows[1:]:
if len(row) <= ix["addr"] or row[ix["pxname"]] != "be_api" or row[ix["svname"]] == "BACKEND":
continue
sv, st, addr = row[ix["svname"]], row[ix["status"]].split(" ")[0], row[ix["addr"]]
if sv in prev and prev[sv] != (st, addr):
self.lb_events.append({"t": round(self.now(), 2), "server": sv, "addr": addr,
"from": prev[sv][0], "to": st})
prev[sv] = (st, addr)
except Exception: # noqa: BLE001 — статистика вспомогательная
pass
time.sleep(0.2)
def history(self):
c, path, items = self.client, "/api/v1/chats/" + self.chat["id"] + "/messages?limit=100", []
while True:
page = c.call("GET", path, actor=self.alice, schema="MessagePage")["json"]
items += page["items"]
if page["next_cursor"] is None:
return items
path = "/api/v1/chats/" + self.chat["id"] + "/messages?limit=100&cursor=" + quote(page["next_cursor"], safe="")
def run(self):
a = self.a
self.client = Client(self.base, timeout=10)
self.alice, _bob, _eve, self.chat = self.client.bootstrap()
self.token = self.alice["token"]
self.t0 = time.monotonic()
threads = [threading.Thread(target=self.worker, args=(n,), daemon=True) for n in range(a.concurrency)]
threads.append(threading.Thread(target=self.poll_lb, daemon=True))
for t in threads:
t.start()
time.sleep(a.action_at)
action = {"command": a.action, "started_s": round(self.now(), 3)}
log = open(a.action_log, "w", encoding="utf-8") if a.action_log else subprocess.DEVNULL
proc = subprocess.Popen(shlex.split(a.action), stdout=log, stderr=subprocess.STDOUT)
rc = proc.wait(timeout=a.duration)
action.update(finished_s=round(self.now(), 3), exit_code=rc)
remaining = a.duration - self.now()
if remaining > 0:
time.sleep(remaining)
self.stop.set()
for t in threads:
t.join(timeout=TIMEOUT + 1)
return self.summarize(action)
def summarize(self, action):
a, t_act = self.a, action["started_s"]
secs = sorted(self.per_sec)
base = [self.per_sec[s]["ok"] for s in secs if 1 <= s < int(t_act)] # 1-я секунда — прогрев
baseline = sum(base) / len(base) if base else 0
after = [(round(t - t_act, 3), k) for t, k in self.errors if t >= t_act]
# Восстановление = конец окна ошибок: после этого момента все запросы до конца
# прогона успешны. Если ошибок не было — 0. Мощность после отказа меряем отдельно:
# при меньшем числе реплик RPS законно ниже (лимиты CPU на реплику).
recovery = after[-1][0] if after else 0.0
tail_secs = [s for s in secs if int(action.get("finished_s", t_act)) + 2 <= s < a.duration - 1]
post = [self.per_sec[s]["ok"] for s in tail_secs]
post_rps = sum(post) / len(post) if post else 0
writes_after = any(self.per_sec[s]["ok"] > 0 for s in tail_secs)
target = a.target_instance
hist = self.history()
ids = [m["id"] for m in hist]
texts = [m["text"] for m in hist]
lost = [i for i in self.confirmed if i not in set(ids)]
timeline = [{"t": s, "ok": self.per_sec[s]["ok"], "err": self.per_sec[s]["err"],
"instances": dict(self.per_sec[s]["inst"]), "versions": dict(self.per_sec[s]["ver"])}
for s in secs]
total_ok = sum(b["ok"] for b in self.per_sec.values())
total_err = len(self.errors)
summary = {
"label": a.label,
"concurrency": a.concurrency, "duration_s": a.duration, "request_timeout_s": TIMEOUT,
"action": action,
"baseline_ok_rps": round(baseline, 1),
"overall_ok_rps": round(total_ok / a.duration, 1),
"requests_ok": total_ok, "errors_total": total_err,
"error_rate": round(total_err / max(1, total_ok + total_err), 5),
"errors_by_kind": dict(Counter(k for _, k in self.errors)),
"error_window_s": [after[0][0], after[-1][0]] if after else None,
"recovery_s": recovery,
"post_action_ok_rps": round(post_rps, 1),
"capacity_ratio": round(post_rps / baseline, 2) if baseline else None,
"latency_ok_ms": {"p50": percentile(self.lat, 50), "p95": percentile(self.lat, 95),
"p99": percentile(self.lat, 99)},
"target_instance": target,
"target_last_seen_s": (round(self.inst_last_seen[target] - t_act, 3)
if target in self.inst_last_seen else None),
"lb_events": [dict(e, t=round(e["t"] - t_act, 2)) for e in self.lb_events],
"posts_retried_same_key": self.retried_posts,
"confirmed_messages": len(self.confirmed),
"history_messages": len(hist), "lost_confirmed": len(lost),
"duplicate_ids": len(ids) - len(set(ids)), "duplicate_texts": len(texts) - len(set(texts)),
"timeline": timeline,
}
summary["pass"] = (summary["lost_confirmed"] == 0 and summary["duplicate_ids"] == 0
and summary["duplicate_texts"] == 0 and action["exit_code"] == 0
and writes_after and recovery <= 10)
return summary
def main():
p = argparse.ArgumentParser(description="Отказ/замена реплики под нагрузкой")
p.add_argument("--base-url", default="http://localhost:8080")
p.add_argument("--stats-url", default="http://127.0.0.1:8404/stats;csv")
p.add_argument("--concurrency", type=int, default=8)
p.add_argument("--duration", type=float, default=40)
p.add_argument("--action-at", type=float, default=10)
p.add_argument("--action", required=True, help="команда без shell, например 'docker stop -t 20 <id>'")
p.add_argument("--action-log")
p.add_argument("--target-instance", help="X-Instance-Id реплики, которую останавливает action")
p.add_argument("--label", default="")
p.add_argument("--output")
a = p.parse_args()
s = Bench(a).run()
brief = {k: v for k, v in s.items() if k != "timeline"}
print(json.dumps(brief, ensure_ascii=False, indent=2))
if a.output:
Path(a.output).write_text(json.dumps(s, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print("PASS" if s["pass"] else "FAIL")
return 0 if s["pass"] else 1
if __name__ == "__main__":
sys.exit(main())