- carry the lab 3 solution over from mtusi2026lab3-safronov (solution/bvt2301-safronov, ce89eba): src, migrations, student-tests, bench, openspec, .claude, infra/haproxy and infra/valkey, own scripts, Dockerfile, compose, pyproject and uv lock - merge Makefile, .gitignore and .dockerignore (the lab 3 versions only add lines to the skeleton, which is the same in lab 4) and .env.example (lab 4 skeleton names listed in the header) - rename the compose project to mtusi-lab4 and the image to :lab4 so the stand does not reuse the lab 3 containers and volumes - update AGENTS.md for lab 4: current lab, origin commit, contract and test files of the new skeleton Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1247 lines
48 KiB
Python
1247 lines
48 KiB
Python
"""Ресурсы профилей уровня «4» (`failover`, `rollout`) без docker.
|
||
|
||
Отсчёты сэмплера `bench/sampler.sh` в режиме `scan` (разбор —
|
||
`scaling.parse_samples`) → интервалы контейнеров и ВМ → агрегаты окон
|
||
фазы или замены, посекундная таблица и разделы `summary.md`. Методика —
|
||
design change `profile-resources` (решения 3–7), что стенд обязан делать,
|
||
— спек `load-benchmark` («Ресурсы профилей отказа и замены»). Только
|
||
stdlib: вызывает `bench/run.py`, самопроверка —
|
||
`uv run python bench/resources.py --selftest`.
|
||
|
||
Все отметки — секунды эпохи на часах ВМ Docker (как в `failover.py`):
|
||
строки сэмплера несут наносекунды, разбор переводит их в секунды.
|
||
"""
|
||
|
||
import bisect
|
||
import math
|
||
import sys
|
||
from dataclasses import dataclass
|
||
from typing import Any
|
||
|
||
import scaling
|
||
|
||
# посекундная таблица и таблица по окнам (решение 7)
|
||
SAMPLE_FIELDS = [
|
||
"phase",
|
||
"window",
|
||
"t_s",
|
||
"role",
|
||
"instance",
|
||
"cpu_cores",
|
||
"throttled_ms",
|
||
"pressure_ms",
|
||
"mem_mib",
|
||
]
|
||
RESOURCE_FIELDS = [
|
||
"phase",
|
||
"mode",
|
||
"window",
|
||
"start_s",
|
||
"end_s",
|
||
"seconds",
|
||
"role",
|
||
"instance",
|
||
"present_s",
|
||
"cpu_mean_cores",
|
||
"cpu_max_cores",
|
||
"cpu_seconds",
|
||
"throttled_ratio",
|
||
"pressure_share",
|
||
"mem_peak_mib",
|
||
"ok_rps",
|
||
"us_per_ok_request",
|
||
"flags",
|
||
]
|
||
# разгон k6 с первого запроса — вне окон (как before_rows[2:] у
|
||
# failover.analyze), с
|
||
WARMUP_S = 2.0
|
||
# сторож: наибольший промежуток между тиками ВМ в нагрузке, с (решение 2)
|
||
GAP_LIMIT_S = 3.0
|
||
# установившиеся окна: только в них CPU на успешный запрос (решение 6)
|
||
STEADY = {"failover": ("before",), "rollout": ("before", "after")}
|
||
# компоненты таблицы по окнам и их порядок (решение 5)
|
||
ROLES = {
|
||
"failover": (
|
||
"api-target",
|
||
"api-other",
|
||
"api-total",
|
||
"postgres",
|
||
"haproxy",
|
||
"valkey",
|
||
"k6",
|
||
"sampler",
|
||
"vm",
|
||
),
|
||
"rollout": (
|
||
"api-old",
|
||
"api-new",
|
||
"api-total",
|
||
"migrate",
|
||
"postgres",
|
||
"haproxy",
|
||
"valkey",
|
||
"k6",
|
||
"sampler",
|
||
"vm",
|
||
),
|
||
}
|
||
WINDOWS = {
|
||
"failover": ("before", "down", "after"),
|
||
"rollout": ("before", "prepare", "during", "after"),
|
||
}
|
||
WARMUP = "warmup"
|
||
TOTAL = "api-total"
|
||
VM = "vm"
|
||
# присутствие короче окна больше чем на столько — пометка partial: CPU
|
||
# остановки после последнего отсчёта не виден (разрешение 1 с)
|
||
PARTIAL_SLACK_S = 0.5
|
||
# /proc/stat — в USER_HZ
|
||
JIFFIES_PER_S = 100
|
||
|
||
WINDOW_TITLES = {
|
||
"failover": {
|
||
"before": "до действия",
|
||
"down": "окно отказа",
|
||
"after": "после возврата",
|
||
},
|
||
"rollout": {
|
||
"before": "до",
|
||
"prepare": "подготовка",
|
||
"during": "замена",
|
||
"after": "после",
|
||
},
|
||
}
|
||
ROLE_TITLES = {
|
||
"api-target": "цель",
|
||
"api-other": "вторая",
|
||
"api-old": "старая",
|
||
"api-new": "новая",
|
||
"api": "реплика",
|
||
TOTAL: "API всего",
|
||
"migrate": "миграция",
|
||
"postgres": "PostgreSQL",
|
||
"haproxy": "HAProxy",
|
||
"valkey": "Valkey",
|
||
"k6": "k6",
|
||
"sampler": "сэмплер",
|
||
VM: "ВМ",
|
||
}
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class Interval:
|
||
"""Прирост счётчиков контейнера (или ВМ) за (t0, t1]."""
|
||
|
||
t0: float
|
||
t1: float
|
||
cpu_s: float
|
||
periods: int
|
||
throttled: int
|
||
throttled_s: float
|
||
pressure_s: float
|
||
mem: int
|
||
# где внутри (t0, t1] шёл CPU: у интервала, задевающего заморозку, —
|
||
# только незамороженная часть; None — весь интервал
|
||
busy: tuple[float, float] | None = None
|
||
|
||
@property
|
||
def length(self) -> float:
|
||
return self.t1 - self.t0
|
||
|
||
@property
|
||
def span(self) -> tuple[float, float]:
|
||
return self.busy or (self.t0, self.t1)
|
||
|
||
|
||
@dataclass
|
||
class Series:
|
||
"""Компонент: интервалы и память на каждом отсчёте (t, байт)."""
|
||
|
||
intervals: list[Interval]
|
||
memory: list[tuple[float, int]]
|
||
seen: bool = True
|
||
|
||
|
||
@dataclass
|
||
class Result:
|
||
"""Итог анализа фазы: строки `resources.csv` и `samples.csv`,
|
||
немаппированные контейнеры (id12)."""
|
||
|
||
rows: list[dict[str, Any]]
|
||
samples: list[dict[str, Any]]
|
||
unmapped: list[str]
|
||
|
||
|
||
# ----------------------------------------------------------- интервалы
|
||
|
||
|
||
def ticks_of(samples: Any) -> list[float]:
|
||
"""Отметки тиков: строки `vm`, без них — строки `cg`."""
|
||
if samples.vm:
|
||
return sorted({p[0] / 1e9 for p in samples.vm})
|
||
return sorted(
|
||
{p[0] / 1e9 for points in samples.cg.values() for p in points},
|
||
)
|
||
|
||
|
||
def points_by_id(samples: Any) -> dict[str, list[tuple[int, ...]]]:
|
||
"""Отсчёты контейнеров по id12; роль строки сэмплера (`-` в `scan`)
|
||
не важна."""
|
||
out: dict[str, list[tuple[int, ...]]] = {}
|
||
for (_, ident), points in samples.cg.items():
|
||
out.setdefault(ident, []).extend(points)
|
||
return {ident: sorted(points) for ident, points in out.items()}
|
||
|
||
|
||
def tick_between(ticks: list[float], a: float, b: float) -> bool:
|
||
"""Есть тик строго между a и b: контейнер на нём не был виден."""
|
||
i = bisect.bisect_right(ticks, a + 1e-6)
|
||
return i < len(ticks) and ticks[i] < b - 1e-6
|
||
|
||
|
||
def tick_before(ticks: list[float], t: float) -> float:
|
||
i = bisect.bisect_left(ticks, t - 1e-6)
|
||
return ticks[i - 1] if i > 0 else t - 1.0
|
||
|
||
|
||
def container_intervals(
|
||
points: list[tuple[int, ...]],
|
||
starts: list[float],
|
||
ticks: list[float],
|
||
) -> list[Interval]:
|
||
"""Интервалы контейнера по решению 3.
|
||
|
||
`points` — (нс, usage_usec, nr_periods, nr_throttled, throttled_usec,
|
||
memory, psi_usec). Сброс — `usage_usec` уменьшился или после
|
||
пропуска тиков между отсчётами есть момент запуска из `starts`: cgroup
|
||
новая. Свежий сегмент (сброс или контейнер впервые виден позже
|
||
первого тика) — значение отсчёта целиком: CPU от момента запуска (он
|
||
же начало интервала), без момента — от предыдущего тика. Первый
|
||
отсчёт на первом тике — база. Пропуск тиков без сброса — продолжение.
|
||
"""
|
||
first_tick = ticks[0] if ticks else None
|
||
out: list[Interval] = []
|
||
prev: tuple[int, ...] | None = None
|
||
for point in points:
|
||
t = point[0] / 1e9
|
||
if prev is None:
|
||
if first_tick is None or t <= first_tick + 1e-6:
|
||
prev = point
|
||
continue
|
||
lower = -math.inf
|
||
fresh = True
|
||
else:
|
||
lower = prev[0] / 1e9
|
||
restarted = tick_between(ticks, lower, t) and any(
|
||
lower < s <= t for s in starts
|
||
)
|
||
fresh = point[1] < prev[1] or restarted
|
||
if fresh:
|
||
moments = [s for s in starts if lower < s <= t]
|
||
begin = max(moments) if moments else tick_before(ticks, t)
|
||
usage, periods, throttled, thr_usec = point[1:5]
|
||
psi = point[6]
|
||
else:
|
||
assert prev is not None
|
||
begin = lower
|
||
usage, periods, throttled, thr_usec = (
|
||
point[i] - prev[i] for i in range(1, 5)
|
||
)
|
||
psi = point[6] - prev[6]
|
||
prev = point
|
||
if t - begin <= 0:
|
||
continue
|
||
out.append(
|
||
Interval(
|
||
t0=begin,
|
||
t1=t,
|
||
cpu_s=usage / 1e6,
|
||
periods=periods,
|
||
throttled=throttled,
|
||
throttled_s=thr_usec / 1e6,
|
||
pressure_s=max(0, psi) / 1e6,
|
||
mem=point[5],
|
||
),
|
||
)
|
||
return out
|
||
|
||
|
||
def thaw(
|
||
intervals: list[Interval],
|
||
frozen: list[tuple[float, float]],
|
||
) -> list[Interval]:
|
||
"""Заморозка (`docker pause` … `unpause`, моменты из событий Docker):
|
||
у замороженного CPU не прирастает, поэтому CPU интервала, который
|
||
задевает начало заморозки, шёл до него, а задевающего конец — после
|
||
(найдено в apply: пропорциональное деление относило часть работы до
|
||
`pause` и всплеск после `unpause` к окну отказа)."""
|
||
out = []
|
||
for interval in intervals:
|
||
busy = None
|
||
for pause, unpause in frozen:
|
||
if interval.t0 < pause < interval.t1 <= unpause:
|
||
busy = (interval.t0, pause)
|
||
elif pause <= interval.t0 < unpause < interval.t1:
|
||
busy = (unpause, interval.t1)
|
||
out.append(
|
||
interval
|
||
if busy is None
|
||
else Interval(**{**interval.__dict__, "busy": busy}),
|
||
)
|
||
return out
|
||
|
||
|
||
def vm_intervals(vm: list[tuple[int, int, int, int]]) -> list[Interval]:
|
||
"""Интервалы ВМ: занятые jiffies и PSI CPU между соседними тиками."""
|
||
out = []
|
||
points = sorted(vm)
|
||
for prev, cur in zip(points, points[1:], strict=False):
|
||
t0, t1 = prev[0] / 1e9, cur[0] / 1e9
|
||
if t1 <= t0:
|
||
continue
|
||
out.append(
|
||
Interval(
|
||
t0=t0,
|
||
t1=t1,
|
||
cpu_s=(cur[1] - prev[1]) / JIFFIES_PER_S,
|
||
periods=0,
|
||
throttled=0,
|
||
throttled_s=0.0,
|
||
pressure_s=max(0, cur[3] - prev[3]) / 1e6,
|
||
mem=0,
|
||
),
|
||
)
|
||
return out
|
||
|
||
|
||
def max_gap(samples: Any, a: float, b: float) -> float:
|
||
"""Наибольший промежуток между тиками ВМ на отрезке [a, b], с концами
|
||
отрезка: сэмплер, умерший посреди нагрузки, даёт большой хвост."""
|
||
inner = [t for t in ticks_of(samples) if a < t < b]
|
||
points = [a, *inner, b]
|
||
return max(
|
||
(cur - prev for prev, cur in zip(points, points[1:], strict=False)),
|
||
default=b - a,
|
||
)
|
||
|
||
|
||
# -------------------------------------------------------------- агрегаты
|
||
|
||
|
||
def overlap(span: tuple[float, float], w0: float, w1: float) -> float:
|
||
return max(0.0, min(span[1], w1) - max(span[0], w0))
|
||
|
||
|
||
def union_length(parts: list[tuple[float, float]]) -> float:
|
||
total = 0.0
|
||
end = -math.inf
|
||
for a, b in sorted(parts):
|
||
if b <= end:
|
||
continue
|
||
total += b - max(a, end)
|
||
end = b
|
||
return total
|
||
|
||
|
||
def aggregate(series: list[Series], w0: float, w1: float) -> dict[str, Any]:
|
||
"""Агрегаты окна [w0, w1) по решению 5; несколько серий — сумма
|
||
(`api-total`): CPU складывается, максимум и пик памяти — по сумме на
|
||
одном тике."""
|
||
seconds = w1 - w0
|
||
empty = {
|
||
"present_s": None,
|
||
"cpu_mean_cores": None,
|
||
"cpu_max_cores": None,
|
||
"cpu_seconds": None,
|
||
"throttled_ratio": None,
|
||
"pressure_share": None,
|
||
"mem_peak_mib": None,
|
||
}
|
||
if seconds <= 0:
|
||
return {**empty, "flags": "empty"}
|
||
if not any(s.seen for s in series):
|
||
return {**empty, "present_s": 0.0, "flags": "absent"}
|
||
cpu = periods = throttled = pressure = 0.0
|
||
covered: list[tuple[float, float]] = []
|
||
rate_by_end: dict[float, float] = {}
|
||
for s in series:
|
||
for interval in s.intervals:
|
||
if overlap((interval.t0, interval.t1), w0, w1) <= 0:
|
||
continue
|
||
covered.append((max(interval.t0, w0), min(interval.t1, w1)))
|
||
# максимум — по всем интервалам, задевающим окно, а не только с
|
||
# концом внутри: иначе в коротком окне среднее с долями
|
||
# граничных интервалов выходило больше максимума (найдено в
|
||
# apply); посекундное значение — как в samples.csv
|
||
rate_by_end.setdefault(interval.t1, 0.0)
|
||
span = interval.span
|
||
part = overlap(span, w0, w1)
|
||
if part <= 0:
|
||
continue
|
||
share = part / (span[1] - span[0])
|
||
cpu += interval.cpu_s * share
|
||
periods += interval.periods * share
|
||
throttled += interval.throttled * share
|
||
pressure += interval.pressure_s * share
|
||
rate_by_end[interval.t1] += interval.cpu_s / interval.length
|
||
memory: dict[float, int] = {}
|
||
for s in series:
|
||
for t, value in s.memory:
|
||
if w0 <= t <= w1:
|
||
memory[t] = memory.get(t, 0) + value
|
||
present = union_length(covered)
|
||
flags = []
|
||
if present <= 0:
|
||
flags.append("absent")
|
||
elif present < seconds - PARTIAL_SLACK_S:
|
||
flags.append("partial")
|
||
if present > 0 and not rate_by_end:
|
||
flags.append("no_samples")
|
||
return {
|
||
"present_s": round(present, 2),
|
||
"cpu_mean_cores": round(cpu / seconds, 4),
|
||
"cpu_max_cores": (
|
||
round(max(rate_by_end.values()), 4) if rate_by_end else None
|
||
),
|
||
"cpu_seconds": round(cpu, 3),
|
||
"throttled_ratio": (
|
||
round(throttled / periods, 4) if periods > 0 else None
|
||
),
|
||
"pressure_share": round(pressure / seconds, 4),
|
||
"mem_peak_mib": (
|
||
round(max(memory.values()) / 2**20, 1)
|
||
if memory and any(memory.values())
|
||
else None
|
||
),
|
||
"flags": " ".join(flags),
|
||
}
|
||
|
||
|
||
def window_of(
|
||
windows: list[tuple[str, float, float]],
|
||
t: float,
|
||
) -> str | None:
|
||
for name, w0, w1 in windows:
|
||
if w0 < t <= w1:
|
||
return name
|
||
return None
|
||
|
||
|
||
def analyze(
|
||
samples: Any,
|
||
roles: dict[str, str],
|
||
windows: list[tuple[str, float, float]],
|
||
*,
|
||
ref: float,
|
||
ok_starts: list[float],
|
||
phase: str,
|
||
mode: str,
|
||
profile: str,
|
||
starts: dict[str, list[float]],
|
||
frozen: dict[str, list[tuple[float, float]]] | None = None,
|
||
) -> Result:
|
||
"""Ресурсы фазы (или замены) по окнам.
|
||
|
||
`roles` — id12 → роль (`api-target`, `postgres`, …; решение 5),
|
||
контейнеры вне него отбрасываются и возвращаются в `unmapped`.
|
||
`windows` — [(имя, начало, конец)] в секундах, первым — разгон
|
||
`warmup` (только в посекундной таблице). `ref` — опорная точка шкалы
|
||
(действие или начало замены), `ok_starts` — отправка успешных
|
||
запросов, `starts` — моменты запуска контейнеров (id12 → секунды),
|
||
`frozen` — заморозки (id12 → [(pause, unpause)]), `profile` —
|
||
`failover` или `rollout`.
|
||
"""
|
||
ticks = ticks_of(samples)
|
||
by_id = points_by_id(samples)
|
||
unmapped = sorted(ident for ident in by_id if ident not in roles)
|
||
series: dict[str, Series] = {}
|
||
for ident, points in by_id.items():
|
||
if ident not in roles:
|
||
continue
|
||
series[ident] = Series(
|
||
intervals=thaw(
|
||
container_intervals(
|
||
points,
|
||
starts.get(ident, []),
|
||
ticks,
|
||
),
|
||
(frozen or {}).get(ident, []),
|
||
),
|
||
memory=[(p[0] / 1e9, p[5]) for p in points],
|
||
)
|
||
vm = Series(intervals=vm_intervals(samples.vm), memory=[])
|
||
first_seen = {
|
||
ident: points[0][0] for ident, points in by_id.items() if points
|
||
}
|
||
|
||
def members(role: str) -> list[str]:
|
||
found = [ident for ident in series if roles[ident] == role]
|
||
return sorted(found, key=lambda i: (first_seen.get(i, 0), i))
|
||
|
||
components: list[tuple[str, str, list[Series]]] = []
|
||
expected = ROLES[profile]
|
||
extra = sorted(
|
||
{roles[i] for i in series} - set(expected),
|
||
key=lambda r: (not r.startswith("api"), r),
|
||
)
|
||
for role in (*expected, *extra):
|
||
if role == VM:
|
||
components.append((VM, "", [vm]))
|
||
elif role == TOTAL:
|
||
idents = [i for i in series if roles[i].startswith("api")]
|
||
components.append(
|
||
(TOTAL, "", [series[i] for i in idents])
|
||
if idents
|
||
else (TOTAL, "", [Series([], [], seen=False)]),
|
||
)
|
||
else:
|
||
idents = members(role)
|
||
if not idents:
|
||
components.append(
|
||
(role, "", [Series([], [], seen=False)]),
|
||
)
|
||
for ident in idents:
|
||
components.append((role, ident, [series[ident]]))
|
||
steady = STEADY[profile]
|
||
ok_sorted = sorted(ok_starts)
|
||
rows = []
|
||
for name, w0, w1 in windows:
|
||
if name == WARMUP:
|
||
continue
|
||
seconds = w1 - w0
|
||
ok = bisect.bisect_left(ok_sorted, w1) - bisect.bisect_left(
|
||
ok_sorted,
|
||
w0,
|
||
)
|
||
ok_rps = round(ok / seconds, 1) if seconds > 0 else None
|
||
for role, ident, parts in components:
|
||
values = aggregate(parts, w0, w1)
|
||
per_request = None
|
||
# контейнера в окне нет (present_s 0) — CPU на запрос не
|
||
# считается: 0 мкс выглядел бы как бесплатный запрос
|
||
if (
|
||
name in steady
|
||
and ok_rps
|
||
and values["present_s"]
|
||
and values["cpu_mean_cores"] is not None
|
||
):
|
||
per_request = round(
|
||
values["cpu_mean_cores"] * 1e6 / ok_rps,
|
||
1,
|
||
)
|
||
rows.append(
|
||
{
|
||
"phase": phase,
|
||
"mode": mode,
|
||
"window": name,
|
||
"start_s": round(w0 - ref, 2),
|
||
"end_s": round(w1 - ref, 2),
|
||
"seconds": round(seconds, 2),
|
||
"role": role,
|
||
"instance": ident,
|
||
**{k: v for k, v in values.items() if k != "flags"},
|
||
"ok_rps": ok_rps,
|
||
"us_per_ok_request": per_request,
|
||
"flags": values["flags"],
|
||
},
|
||
)
|
||
load0 = windows[0][1] if windows else 0.0
|
||
load1 = windows[-1][2] if windows else 0.0
|
||
per_second = []
|
||
named = [(ident, roles[ident], s) for ident, s in series.items()]
|
||
named.append(("", VM, vm))
|
||
for ident, role, s in named:
|
||
for interval in s.intervals:
|
||
if not load0 < interval.t1 <= load1:
|
||
continue
|
||
length = interval.length
|
||
per_second.append(
|
||
{
|
||
"phase": phase,
|
||
# окно — по концу той части интервала, где шёл CPU:
|
||
# у интервала, задевающего начало заморозки, это
|
||
# момент `pause`, как у агрегатов (`thaw`); t_s —
|
||
# по-прежнему момент отсчёта
|
||
"window": window_of(windows, interval.span[1]),
|
||
"t_s": round(interval.t1 - ref, 2),
|
||
"role": role,
|
||
"instance": ident,
|
||
"cpu_cores": round(interval.cpu_s / length, 4),
|
||
"throttled_ms": (
|
||
round(interval.throttled_s * 1000 / length, 2)
|
||
if role != VM
|
||
else None
|
||
),
|
||
"pressure_ms": round(
|
||
interval.pressure_s * 1000 / length,
|
||
2,
|
||
),
|
||
"mem_mib": (
|
||
round(interval.mem / 2**20, 1) if role != VM else None
|
||
),
|
||
},
|
||
)
|
||
order = {role: i for i, role in enumerate((*expected, *extra))}
|
||
per_second.sort(
|
||
key=lambda r: (r["t_s"], order.get(r["role"], 99), r["instance"]),
|
||
)
|
||
return Result(rows=rows, samples=per_second, unmapped=unmapped)
|
||
|
||
|
||
# ---------------------------------------------------------------- вывод
|
||
|
||
|
||
def num(value: Any) -> float | None:
|
||
if value is None or value == "":
|
||
return None
|
||
return float(value)
|
||
|
||
|
||
def cores(value: Any) -> str:
|
||
v = num(value)
|
||
return "—" if v is None else f"{v:.2f}"
|
||
|
||
|
||
def cell(row: dict[str, Any], *, present: bool = False) -> str:
|
||
"""`ср. / макс. ядер; пик МиБ` (и `(N с)`, если контейнер был не всё
|
||
окно)."""
|
||
flags = str(row.get("flags") or "").split()
|
||
if "empty" in flags:
|
||
return "пустое окно"
|
||
if num(row.get("cpu_mean_cores")) is None:
|
||
return "нет"
|
||
text = f"{cores(row['cpu_mean_cores'])} / {cores(row['cpu_max_cores'])}"
|
||
mem = num(row.get("mem_peak_mib"))
|
||
if mem is not None:
|
||
text += f"; {mem:.0f}"
|
||
if present and ("partial" in flags or "absent" in flags):
|
||
text += f" ({num(row.get('present_s')) or 0:g} с)"
|
||
return text
|
||
|
||
|
||
def per_request(row: dict[str, Any] | None) -> str:
|
||
if row is None:
|
||
return "—"
|
||
v = num(row.get("us_per_ok_request"))
|
||
return "—" if v is None else f"{v:.0f}"
|
||
|
||
|
||
def label(row: dict[str, Any]) -> str:
|
||
title = ROLE_TITLES.get(row["role"], row["role"])
|
||
return f"{title} `{row['instance']}`" if row["instance"] else title
|
||
|
||
|
||
def pick(
|
||
rows: list[dict[str, Any]],
|
||
window: str,
|
||
role: str,
|
||
) -> list[dict[str, Any]]:
|
||
return [r for r in rows if r["window"] == window and r["role"] == role]
|
||
|
||
|
||
def first(
|
||
rows: list[dict[str, Any]],
|
||
window: str,
|
||
role: str,
|
||
) -> dict[str, Any] | None:
|
||
found = pick(rows, window, role)
|
||
return found[0] if found else None
|
||
|
||
|
||
DEFINITIONS = (
|
||
"Ресурсы — сэмплер `bench/sampler.sh` в режиме `scan` (свой контейнер "
|
||
"без сети, лимит 0,25 CPU / 128 МиБ): раз в секунду счётчики cgroup "
|
||
"каждого контейнера стенда, k6 и самого сэмплера и `/proc/stat` ВМ, на "
|
||
"тех же часах ВМ, что шкала. Ячейка — среднее CPU за окно (CPU-секунды "
|
||
"/ длина окна, ядер) / наибольшее посекундное: CPU интервала между "
|
||
"отсчётами / его длина по всем интервалам, задевающим окно, включая "
|
||
"граничный (у заморозки — только с CPU в окне); строка граничного "
|
||
"интервала в `samples.csv` помечена соседним окном (окно строки — по "
|
||
"концу интервала, у заморозки — по концу незамороженной части); пик "
|
||
"памяти cgroup "
|
||
"(`memory.current`, с кэшем файлов) по отсчётам, МиБ; «(N с)» — "
|
||
"сколько секунд окна контейнер существовал, если меньше окна; «нет» — "
|
||
"контейнера не было ни в одном отсчёте. API всего — сумма по репликам, "
|
||
"пик — наибольшая сумма памяти на одном отсчёте. ВМ — занятые ядра ВМ "
|
||
"Docker целиком (в них и k6, и сэмплер). Полные значения — "
|
||
"`resources.csv`, посекундные — `samples.csv`."
|
||
)
|
||
|
||
|
||
def render_failover(
|
||
rows: list[dict[str, Any]],
|
||
phases: list[str],
|
||
) -> list[str]:
|
||
"""Раздел «Ресурсы по фазам» и таблица CPU на запрос до действия."""
|
||
titles = WINDOW_TITLES["failover"]
|
||
columns = (
|
||
TOTAL,
|
||
"api-target",
|
||
"api-other",
|
||
"postgres",
|
||
"haproxy",
|
||
"valkey",
|
||
"k6",
|
||
"sampler",
|
||
VM,
|
||
)
|
||
lines = [
|
||
"## Ресурсы по фазам",
|
||
"",
|
||
DEFINITIONS,
|
||
"",
|
||
"Окна: до действия — от первого запроса фазы + 2 с (разгон k6) до "
|
||
"действия; окно отказа — от действия до возврата; после возврата — "
|
||
"до отправки последнего запроса фазы. Цель — реплика, над которой "
|
||
"выполнено действие, вторая — другая реплика.",
|
||
"",
|
||
"| Фаза | Окно | "
|
||
+ " | ".join(ROLE_TITLES[c] for c in columns)
|
||
+ " | Успешных/с |",
|
||
"|---|---|" + "---|" * (len(columns) + 1),
|
||
]
|
||
for phase in phases:
|
||
mine = [r for r in rows if r["phase"] == phase]
|
||
for window in WINDOWS["failover"]:
|
||
cells = []
|
||
ok_rps = None
|
||
for role in columns:
|
||
row = first(mine, window, role)
|
||
cells.append(cell(row) if row else "—")
|
||
if row is not None:
|
||
ok_rps = row.get("ok_rps")
|
||
lines.append(
|
||
f"| {phase} | {titles[window]} | "
|
||
+ " | ".join(cells)
|
||
+ f" | {ok_rps if ok_rps is not None else '—'} |",
|
||
)
|
||
lines += [
|
||
"",
|
||
"### CPU на успешный запрос до действия, мкс",
|
||
"",
|
||
"CPU компонента × 10⁶ / успешных в секунду в окне до действия: обе "
|
||
"реплики в LB, ошибок нет, процессы не запускаются и не "
|
||
"останавливаются. В окне отказа и после возврата CPU на запрос не "
|
||
"считается: там CPU уходит на ошибки, ожидание зависшей реплики и "
|
||
"повторы LB, а после возврата — на запуск процесса реплики (импорт, "
|
||
"uvicorn, пул), и делитель «успешные» с этой работой не связан. Там "
|
||
"— только абсолютные числа выше. Смесь (50 % записи, 50 % чтения "
|
||
"страницы чата из 1 000 сообщений) другая, чем у серий трека 1: "
|
||
"с их CPU на запрос числа напрямую не сравниваются.",
|
||
"",
|
||
"| Фаза | " + " | ".join(ROLE_TITLES[c] for c in columns) + " |",
|
||
"|---|" + "---|" * len(columns),
|
||
]
|
||
for phase in phases:
|
||
mine = [r for r in rows if r["phase"] == phase]
|
||
lines.append(
|
||
f"| {phase} | "
|
||
+ " | ".join(
|
||
per_request(first(mine, "before", role)) for role in columns
|
||
)
|
||
+ " |",
|
||
)
|
||
lines.append("")
|
||
return lines
|
||
|
||
|
||
def render_failover_phase(
|
||
rows: list[dict[str, Any]],
|
||
phase: str,
|
||
) -> list[str]:
|
||
"""Таблица «компонент × окно» в разделе фазы."""
|
||
titles = WINDOW_TITLES["failover"]
|
||
mine = [r for r in rows if r["phase"] == phase]
|
||
if not mine:
|
||
return []
|
||
lines = [
|
||
"Ресурсы фазы: ср. / макс. ядер; пик памяти, МиБ (секунд в окне, "
|
||
"если контейнер был не всё окно).",
|
||
"",
|
||
"| Компонент | "
|
||
+ " | ".join(titles[w] for w in WINDOWS["failover"])
|
||
+ " |",
|
||
"|---|" + "---|" * len(WINDOWS["failover"]),
|
||
]
|
||
for role in ROLES["failover"]:
|
||
for row in pick(mine, "before", role):
|
||
cells = []
|
||
for window in WINDOWS["failover"]:
|
||
match = next(
|
||
(
|
||
r
|
||
for r in pick(mine, window, role)
|
||
if r["instance"] == row["instance"]
|
||
),
|
||
None,
|
||
)
|
||
cells.append(cell(match, present=True) if match else "—")
|
||
lines.append(f"| {label(row)} | " + " | ".join(cells) + " |")
|
||
lines.append("")
|
||
return lines
|
||
|
||
|
||
def render_rollout(rows: list[dict[str, Any]]) -> list[str]:
|
||
"""Раздел «Ресурсы по окнам замены»."""
|
||
titles = WINDOW_TITLES["rollout"]
|
||
windows = WINDOWS["rollout"]
|
||
head = []
|
||
for window in windows:
|
||
row = next((r for r in rows if r["window"] == window), None)
|
||
span = (
|
||
f" ({num(row['start_s']):g}…{num(row['end_s']):g} с)"
|
||
if row
|
||
else ""
|
||
)
|
||
head.append(titles[window] + span)
|
||
lines = [
|
||
"## Ресурсы по окнам замены",
|
||
"",
|
||
DEFINITIONS,
|
||
"",
|
||
"Окна (секунды от начала замены): до — от первого запроса + 2 с "
|
||
"(разгон k6) до первого обращения скрипта к стенду (`exec_start` в "
|
||
"событиях проекта, кроме проверок здоровья контейнеров); подготовка "
|
||
"— проверки скрипта и сборка образа "
|
||
"до создания контейнера миграции; замена — до удаления последней "
|
||
"старой реплики; после — до отправки последнего запроса. Старые и "
|
||
"новые реплики — каждая отдельно со своим `X-Instance-Id`; на пике "
|
||
"замены работают три реплики.",
|
||
"",
|
||
"| Компонент | " + " | ".join(head) + " |",
|
||
"|---|" + "---|" * len(windows),
|
||
]
|
||
prepare = [r for r in rows if r["window"] == "prepare"]
|
||
if prepare and all("empty" in str(r["flags"]) for r in prepare):
|
||
lines[4] += (
|
||
" Начало подготовки не найдено: окно «подготовка» пусто, «до» "
|
||
"кончается на начале замены."
|
||
)
|
||
order = [*ROLES["rollout"]]
|
||
order += sorted({r["role"] for r in rows} - set(order))
|
||
for role in order:
|
||
for row in pick(rows, "before", role) or pick(rows, "during", role):
|
||
cells = []
|
||
for window in windows:
|
||
match = next(
|
||
(
|
||
r
|
||
for r in pick(rows, window, role)
|
||
if r["instance"] == row["instance"]
|
||
),
|
||
None,
|
||
)
|
||
cells.append(cell(match, present=True) if match else "—")
|
||
lines.append(f"| {label(row)} | " + " | ".join(cells) + " |")
|
||
steady = STEADY["rollout"]
|
||
lines += [
|
||
"",
|
||
"### CPU на успешный запрос до и после замены, мкс",
|
||
"",
|
||
"CPU компонента × 10⁶ / успешных в секунду в окнах до и после: две "
|
||
"реплики одной версии, скрипт не работает. В подготовке и замене CPU "
|
||
"на запрос не считается: CPU там идёт на сборку образа, миграцию, "
|
||
"запуск третьей реплики, дренаж и остановку старой — цену процедуры, "
|
||
"а не запросов; там — только абсолютные числа выше. Смесь (50 % "
|
||
"записи, 50 % чтения страницы чата из 1 000 сообщений) другая, чем у "
|
||
"серий трека 1: с их CPU на запрос числа напрямую не сравниваются.",
|
||
"",
|
||
"| Компонент | " + " | ".join(titles[w] for w in steady) + " |",
|
||
"|---|" + "---|" * len(steady),
|
||
]
|
||
for role in (TOTAL, "postgres", "haproxy", "valkey", "k6", "sampler", VM):
|
||
lines.append(
|
||
f"| {ROLE_TITLES[role]} | "
|
||
+ " | ".join(per_request(first(rows, w, role)) for w in steady)
|
||
+ " |",
|
||
)
|
||
ok = [
|
||
f"{titles[w]} {first(rows, w, VM)['ok_rps']}"
|
||
for w in windows
|
||
if first(rows, w, VM) is not None
|
||
]
|
||
lines += ["", "Успешных в секунду по окнам: " + ", ".join(ok) + ".", ""]
|
||
return lines
|
||
|
||
|
||
def terminal_line(rows: list[dict[str, Any]], profile: str) -> str:
|
||
"""Строка ресурсов фазы в терминал: средние ядра по окнам."""
|
||
windows = WINDOWS[profile]
|
||
roles = (
|
||
(TOTAL, "api-target", "postgres", VM, "sampler")
|
||
if profile == "failover"
|
||
else (TOTAL, "migrate", "postgres", VM, "sampler")
|
||
)
|
||
parts = []
|
||
for role in roles:
|
||
values = []
|
||
for window in windows:
|
||
row = first(rows, window, role)
|
||
values.append(cores(row["cpu_mean_cores"]) if row else "—")
|
||
parts.append(f"{ROLE_TITLES[role]} {'/'.join(values)}")
|
||
return f"resources, mean cores {'/'.join(windows)}: " + ", ".join(parts)
|
||
|
||
|
||
# ------------------------------------------------------- самопроверка
|
||
|
||
|
||
def selftest() -> int:
|
||
"""Синтетические строки сэмплера (решение 12)."""
|
||
failures: list[str] = []
|
||
|
||
def expect(name: str, got: Any, want: Any, tol: float = 1e-6) -> None:
|
||
if isinstance(want, float) and isinstance(got, float | int):
|
||
if abs(got - want) > tol:
|
||
failures.append(f"{name}: got {got!r}, want {want!r}")
|
||
return
|
||
if got != want:
|
||
failures.append(f"{name}: got {got!r}, want {want!r}")
|
||
|
||
base = 1_800_000_000
|
||
mib = 2**20
|
||
|
||
def ns(t: float) -> int:
|
||
return int(round((base + t) * 1e9))
|
||
|
||
lines: list[str] = []
|
||
|
||
def cg(t: float, ident: str, usage: float, mem: int, **kw: int) -> None:
|
||
lines.append(
|
||
f"cg {ns(t)} - {ident} {int(usage * 1e6)} "
|
||
f"{kw.get('periods', 0)} {kw.get('throttled', 0)} "
|
||
f"{kw.get('thr', 0)} {mem} {kw.get('psi', 0)}",
|
||
)
|
||
|
||
ids = {
|
||
"steady": "a" * 12,
|
||
"stopped": "b" * 12,
|
||
"paused": "c" * 12,
|
||
"new": "d" * 12,
|
||
"gap": "e" * 12,
|
||
"alien": "f" * 12,
|
||
}
|
||
# тики 0…14, ВМ: 2 ядра заняты (200 jiffies в секунду)
|
||
for i in range(15):
|
||
lines.append(f"vm {ns(i)} {200 * i} {1200 * i} {1000 * i}")
|
||
# непрерывный: 0,5 ядра, троттлинг в каждом десятом периоде
|
||
cg(
|
||
i,
|
||
ids["steady"],
|
||
0.5 * i,
|
||
100 * mib,
|
||
periods=10 * i,
|
||
throttled=i,
|
||
)
|
||
# остановлен после тика 5, запущен в 9,6 (новая cgroup): на тике 10
|
||
# 0,2 с от запуска, дальше 0,5 ядра
|
||
if i <= 5:
|
||
cg(i, ids["stopped"], 10 + 0.5 * i, 80 * mib)
|
||
elif i >= 10:
|
||
cg(i, ids["stopped"], 0.2 + 0.5 * (i - 10), 60 * mib)
|
||
# заморожен с 5 до 9,6: счётчик стоит, память та же; дальше 0,4
|
||
if i <= 5:
|
||
usage = 0.4 * i
|
||
elif i <= 9:
|
||
usage = 2.0
|
||
else:
|
||
usage = 2.16 + 0.4 * (i - 10)
|
||
cg(i, ids["paused"], usage, 70 * mib)
|
||
# новая реплика: запуск 6,4, на тике 7 — 0,3 с, дальше 0,6 ядра
|
||
if i >= 7:
|
||
cg(i, ids["new"], 0.3 + 0.6 * (i - 7), 90 * mib)
|
||
# ложный пропуск тиков 4 и 5 без сброса: 0,25 ядра непрерывно
|
||
if i not in (4, 5):
|
||
cg(i, ids["gap"], 0.25 * i, 50 * mib)
|
||
cg(i, ids["alien"], 5.0 * i, 10 * mib)
|
||
samples = scaling.parse_samples("\n".join(lines))
|
||
roles = {
|
||
ids["steady"]: "postgres",
|
||
ids["stopped"]: "api-target",
|
||
ids["paused"]: "api-other",
|
||
ids["new"]: "k6",
|
||
ids["gap"]: "haproxy",
|
||
}
|
||
t = base
|
||
windows = [
|
||
(WARMUP, t + 0.0, t + 2.0),
|
||
("before", t + 2.0, t + 5.5),
|
||
("down", t + 5.5, t + 9.6),
|
||
("after", t + 9.6, t + 14.0),
|
||
]
|
||
ok_starts = [t + 2.0 + k / 100 for k in range(350)]
|
||
result = analyze(
|
||
samples,
|
||
roles,
|
||
windows,
|
||
ref=t + 5.5,
|
||
ok_starts=ok_starts,
|
||
phase="01-stop-r1",
|
||
mode="stop",
|
||
profile="failover",
|
||
starts={ids["stopped"]: [t + 9.6], ids["new"]: [t + 6.4]},
|
||
)
|
||
|
||
def row(window: str, role: str) -> dict[str, Any]:
|
||
found = first(result.rows, window, role)
|
||
assert found is not None, (window, role)
|
||
return found
|
||
|
||
expect("unmapped", result.unmapped, [ids["alien"]])
|
||
expect(
|
||
"rows",
|
||
len(result.rows),
|
||
len(WINDOWS["failover"]) * len(ROLES["failover"]),
|
||
)
|
||
# непрерывный контейнер; деление интервала на границе окна
|
||
expect("steady before", row("before", "postgres")["cpu_mean_cores"], 0.5)
|
||
expect("steady seconds", row("before", "postgres")["cpu_seconds"], 1.75)
|
||
expect("steady max", row("before", "postgres")["cpu_max_cores"], 0.5)
|
||
expect(
|
||
"steady throttled",
|
||
row("before", "postgres")["throttled_ratio"],
|
||
0.1,
|
||
)
|
||
expect("steady mem", row("before", "postgres")["mem_peak_mib"], 100.0)
|
||
expect("steady flags", row("before", "postgres")["flags"], "")
|
||
# остановка, пропуск тиков и запуск со сбросом
|
||
down = row("down", "api-target")
|
||
expect("stopped down cpu", down["cpu_mean_cores"], 0.0)
|
||
expect("stopped down present", down["present_s"], 0.0)
|
||
expect("stopped down flags", down["flags"], "absent")
|
||
after = row("after", "api-target")
|
||
expect("stopped after seconds", after["cpu_seconds"], 2.2)
|
||
expect("stopped after max", after["cpu_max_cores"], 0.5)
|
||
expect("stopped after mem", after["mem_peak_mib"], 60.0)
|
||
# CPU после последнего отсчёта до остановки (5 → 5,5) не виден
|
||
expect("stopped before", row("before", "api-target")["cpu_seconds"], 1.5)
|
||
# пауза: прирост 0, память та же, присутствует всё окно; в окно
|
||
# попадает только доля интервала разморозки (9; 10] — 0,16 × 0,6
|
||
paused = row("down", "api-other")
|
||
expect("paused cpu", paused["cpu_seconds"], 0.096)
|
||
# максимум — по интервалам, задевающим окно: (9; 10] после разморозки
|
||
expect("paused max", paused["cpu_max_cores"], 0.16)
|
||
expect("paused mem", paused["mem_peak_mib"], 70.0)
|
||
expect("paused flags", paused["flags"], "")
|
||
# заморозка из событий (5,3 … 9,6): CPU интервала разморозки — после
|
||
# unpause, окно отказа — без прироста
|
||
thawed = analyze(
|
||
samples,
|
||
roles,
|
||
windows,
|
||
ref=t + 5.5,
|
||
ok_starts=ok_starts,
|
||
phase="02-pause-r2",
|
||
mode="pause",
|
||
profile="failover",
|
||
starts={ids["stopped"]: [t + 9.6], ids["new"]: [t + 6.4]},
|
||
frozen={ids["paused"]: [(t + 5.3, t + 9.6)]},
|
||
)
|
||
expect(
|
||
"thawed down cpu",
|
||
first(thawed.rows, "down", "api-other")["cpu_seconds"],
|
||
0.0,
|
||
)
|
||
expect(
|
||
"thawed down max",
|
||
first(thawed.rows, "down", "api-other")["cpu_max_cores"],
|
||
0.0,
|
||
)
|
||
expect(
|
||
"thawed after",
|
||
first(thawed.rows, "after", "api-other")["cpu_seconds"],
|
||
0.16 + 0.4 * 4,
|
||
)
|
||
expect(
|
||
"thawed present",
|
||
first(thawed.rows, "down", "api-other")["flags"],
|
||
"",
|
||
)
|
||
# `pause` ровно на действии, как в фазе: 0,5 ядра до 5,5, заморозка
|
||
# до 9,6, дальше 0,5. Интервал (5; 6] несёт 0,25 с CPU до `pause`:
|
||
# его строка в samples.csv — в окне до действия, у цели в окне отказа
|
||
# нет строк с CPU > 0
|
||
lines.clear()
|
||
for i in range(15):
|
||
lines.append(f"vm {ns(i)} {200 * i} {1200 * i} {1000 * i}")
|
||
if i <= 5:
|
||
usage = 0.5 * i
|
||
elif i <= 9:
|
||
usage = 2.75
|
||
else:
|
||
usage = 2.95 + 0.5 * (i - 10)
|
||
cg(i, ids["paused"], usage, 70 * mib)
|
||
paused_phase = analyze(
|
||
scaling.parse_samples("\n".join(lines)),
|
||
{ids["paused"]: "api-target"},
|
||
windows,
|
||
ref=t + 5.5,
|
||
ok_starts=ok_starts,
|
||
phase="05-pause-r1",
|
||
mode="pause",
|
||
profile="failover",
|
||
starts={},
|
||
frozen={ids["paused"]: [(t + 5.5, t + 9.6)]},
|
||
)
|
||
target = [r for r in paused_phase.samples if r["role"] == "api-target"]
|
||
expect(
|
||
"pause samples down",
|
||
[r["cpu_cores"] for r in target if r["window"] == "down"],
|
||
[0.0, 0.0, 0.0],
|
||
)
|
||
expect(
|
||
"pause samples before",
|
||
[
|
||
(r["t_s"], r["cpu_cores"])
|
||
for r in target
|
||
if r["window"] == "before" and r["t_s"] > 0
|
||
],
|
||
[(0.5, 0.25)],
|
||
)
|
||
expect(
|
||
"pause samples after",
|
||
next(r["cpu_cores"] for r in target if r["t_s"] == 4.5),
|
||
0.2,
|
||
)
|
||
pause_rows = {
|
||
w: first(paused_phase.rows, w, "api-target")
|
||
for w in WINDOWS["failover"]
|
||
}
|
||
expect("pause before cpu", pause_rows["before"]["cpu_seconds"], 1.75)
|
||
expect("pause down cpu", pause_rows["down"]["cpu_seconds"], 0.0)
|
||
expect("pause down max", pause_rows["down"]["cpu_max_cores"], 0.0)
|
||
expect("pause after cpu", pause_rows["after"]["cpu_seconds"], 2.2)
|
||
# новая реплика: CPU от момента запуска, первый интервал (6,4; 7]
|
||
k6 = row("down", "k6")
|
||
expect("new seconds", k6["cpu_seconds"], 0.3 + 0.6 * 2 + 0.6 * 0.6)
|
||
expect("new max", k6["cpu_max_cores"], 0.6)
|
||
expect("new present", k6["present_s"], 9.6 - 6.4)
|
||
expect("new flags", k6["flags"], "partial")
|
||
expect("new before", row("before", "k6")["flags"], "absent")
|
||
# ложный пропуск без сброса — продолжение с тем же темпом
|
||
expect("gap down", row("down", "haproxy")["cpu_mean_cores"], 0.25)
|
||
expect("gap before", row("before", "haproxy")["cpu_mean_cores"], 0.25)
|
||
# сумма по репликам и пик суммарной памяти
|
||
total = row("before", TOTAL)
|
||
expect("total cpu", total["cpu_seconds"], 1.5 + 1.2)
|
||
expect("total mem", total["mem_peak_mib"], 150.0)
|
||
expect("total down mem", row("down", TOTAL)["mem_peak_mib"], 70.0)
|
||
expect("total after max", row("after", TOTAL)["cpu_max_cores"], 0.9)
|
||
# ВМ: 2 ядра, PSI 1 мс/с
|
||
expect("vm cpu", row("before", VM)["cpu_mean_cores"], 2.0)
|
||
expect("vm pressure", row("before", VM)["pressure_share"], 0.001)
|
||
# CPU на запрос только в установившемся окне: 100 успешных/с
|
||
expect("ok rps", row("before", VM)["ok_rps"], 100.0)
|
||
expect(
|
||
"per request before",
|
||
row("before", "postgres")["us_per_ok_request"],
|
||
5000.0,
|
||
)
|
||
expect(
|
||
"per request down",
|
||
row("down", "postgres")["us_per_ok_request"],
|
||
None,
|
||
)
|
||
expect(
|
||
"per request after",
|
||
row("after", "postgres")["us_per_ok_request"],
|
||
None,
|
||
)
|
||
# контейнера в окне нет — CPU на запрос не считается, а не 0
|
||
expect(
|
||
"per request absent",
|
||
row("before", "k6")["us_per_ok_request"],
|
||
None,
|
||
)
|
||
# посекундная таблица: без чужого, с окнами и секундами от действия
|
||
roles_seen = {r["role"] for r in result.samples}
|
||
expect(
|
||
"samples alien",
|
||
ids["alien"] in {r["instance"] for r in result.samples},
|
||
False,
|
||
)
|
||
expect("samples roles", "vm" in roles_seen and "k6" in roles_seen, True)
|
||
first_new = min(
|
||
r["t_s"] for r in result.samples if r["instance"] == ids["new"]
|
||
)
|
||
expect("samples new first", first_new, 1.5)
|
||
windows_seen = {r["window"] for r in result.samples}
|
||
expect(
|
||
"samples windows",
|
||
windows_seen,
|
||
{WARMUP, "before", "down", "after"},
|
||
)
|
||
# сторож: тики раз в секунду; хвост без тиков — большой промежуток
|
||
expect("gap ok", max_gap(samples, t + 1.5, t + 14.0), 1.0)
|
||
expect("gap tail", max_gap(samples, t + 1.5, t + 20.0), 6.0)
|
||
# пустое окно (начало подготовки не найдено)
|
||
empty = aggregate([Series([], [])], t + 3, t + 3)
|
||
expect("empty window", empty["flags"], "empty")
|
||
# рендер не падает и называет причину пустых ячеек
|
||
text = "\n".join(
|
||
render_failover(result.rows, ["01-stop-r1"])
|
||
+ render_failover_phase(result.rows, "01-stop-r1"),
|
||
)
|
||
expect("render reason", "делитель «успешные»" in text, True)
|
||
expect("terminal", terminal_line(result.rows, "failover")[:9], "resources")
|
||
# замена: роли старых и новых, пустая подготовка, CPU на запрос до и
|
||
# после, рендер раздела
|
||
rollout = analyze(
|
||
samples,
|
||
{
|
||
ids["stopped"]: "api-old",
|
||
ids["paused"]: "api-old",
|
||
ids["new"]: "api-new",
|
||
ids["steady"]: "postgres",
|
||
},
|
||
[
|
||
(WARMUP, t + 0.0, t + 2.0),
|
||
("before", t + 2.0, t + 5.0),
|
||
("prepare", t + 5.0, t + 5.0),
|
||
("during", t + 5.0, t + 10.0),
|
||
("after", t + 10.0, t + 14.0),
|
||
],
|
||
ref=t + 5.0,
|
||
ok_starts=ok_starts,
|
||
phase="rollout",
|
||
mode="rollout",
|
||
profile="rollout",
|
||
starts={ids["new"]: [t + 6.4]},
|
||
)
|
||
expect(
|
||
"rollout rows",
|
||
len(rollout.rows),
|
||
4 * (len(ROLES["rollout"]) + 1),
|
||
)
|
||
expect(
|
||
"rollout migrate",
|
||
first(rollout.rows, "during", "migrate")["flags"],
|
||
"absent",
|
||
)
|
||
expect(
|
||
"rollout prepare",
|
||
first(rollout.rows, "prepare", "postgres")["flags"],
|
||
"empty",
|
||
)
|
||
expect(
|
||
"rollout per request",
|
||
[
|
||
first(rollout.rows, w, "postgres")["us_per_ok_request"] is None
|
||
for w in WINDOWS["rollout"]
|
||
],
|
||
[False, True, True, True],
|
||
)
|
||
text = "\n".join(render_rollout(rollout.rows))
|
||
expect("rollout render", "Начало подготовки не найдено" in text, True)
|
||
if failures:
|
||
print("selftest failed:\n " + "\n ".join(failures), flush=True)
|
||
return 1
|
||
print("selftest ok", flush=True)
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
if sys.argv[1:] == ["--selftest"]:
|
||
sys.exit(selftest())
|
||
print("usage: uv run python bench/resources.py --selftest", flush=True)
|
||
sys.exit(2)
|