forked from mtusi2026/mtusi2026lab4
Перенос 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.
265 lines
13 KiB
Python
265 lines
13 KiB
Python
#!/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())
|