Files
mtusi2026lab4/student-tests/failover_bench.py
T
zemiles c5a07dc253 ЛР 4 — БПИ2303 — Лазарев — на 4
Перенос lab3 и вложения в приватном S3 (SeaweedFS 4.50).

- POST /chats/{id}/attachments: потоковый приём PNG/JPEG в безымянный
  временный файл, SHA-256 на лету, лимиты 10 MiB / 40 Мпикс до чтения
  и декодирования, проверка MIME по содержимому, валидация filename.
- Порядок записи pending -> S3 PUT -> ready с компенсацией; janitor
  сверяет БД и bucket (dry-run, grace period, advisory lock).
- GET /attachments/{id} и /content только участникам чата, без redirect;
  attachment_ids в сообщениях с проверкой принадлежности чату.
- Отдельные S3-ключи api/janitor/admin с ограниченными правами,
  идемпотентный bootstrap bucket, служебные порты SeaweedFS закрыты.
- Ограничение параллельных S3 PUT и MALLOC_ARENA_MAX: пик RSS API
  178-189 -> 95-102 MiB; лимиты памяти и restart для SeaweedFS после OOM.
- Тесты уровня 4 (негативные, failover вложений, отказы S3/БД, память)
  и доказательства в evidence/, заполнен REPORT.md.
2026-11-07 01:44:58 +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())