lab3: путь записи сообщения одним оператором (C2)

Владелец ключа идемпотентности больше не оркестрируется в приложении: проверка
членства, заявка ключа, вставка сообщения, инкремент версии чата (якорь
инвалидации кэша) и сохранение тела ответа выполняются одним оператором SQL,
атомарность которого обеспечивает сам оператор.

- messages.repository: createOnce() одним запросом вместо трёх (проверка
  членства + INSERT + UPDATE version) и явной транзакции; тело ответа строится
  в SQL и служит источником истины и для первого ответа, и для повторов.
- idempotency.repository: read() читает сохранённый ответ вместе с повторной
  проверкой доступа, delete/purge не изменились; claim/store внутри транзакции
  больше не нужны.
- messages.service: без DatabaseClient и без предварительного chatsService.
  getForUser в пути записи; ключ обязателен, тело проверяется до обращения к БД,
  просроченный ключ освобождается и занимается заново.

Итог: 1 round trip на запись вместо 8 и 2 вместо 3 на повтор; короче удержание
блокировки строки chats, что и проверяется A/B на профиле горячего чата.

Проверено: npm run build, tsc, unit-тесты, lint, публичный smoke и black-box
набор приложения (включая конкурентный повтор с одним ключом) на стенде с
образом mtusi-messenger:lab3-after.
This commit is contained in:
2026-10-15 22:48:22 +03:00
parent 410e1ea3ad
commit 5a5a8fe5cb
7 changed files with 601 additions and 323 deletions
+327 -108
View File
@@ -45,6 +45,7 @@ from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
ENV_FILE = ROOT / '.env'
STAND_ENV = ROOT / '.env.stand'
STAND_STATE = ROOT / '.env.stand.json'
QUIESCE_STATE = ROOT / '.lab3-quiesce.json'
RAW_DIR = ROOT / 'evidence/track1/raw'
TRACK1_DIR = ROOT / 'evidence/track1'
@@ -172,7 +173,7 @@ def render_stand_env(config: dict) -> str:
def load_stand_config() -> dict:
stored = read_json(STAND_ENV.with_suffix('.json'), None)
stored = read_json(STAND_STATE, None)
config = dict(DEFAULT_STAND)
if STAND_ENV.exists():
for line in STAND_ENV.read_text().splitlines():
@@ -191,11 +192,20 @@ def numeric(value: str) -> float | int:
def save_stand_config(config: dict) -> dict:
STAND_ENV.write_text(render_stand_env(config))
write_json(
STAND_ENV.with_suffix('.json'),
{key: str(value) for key, value in config.items()},
)
"""Пишет .env.stand и его машинно-читаемую копию.
Копия сохраняется уже с производными значениями (лимиты на реплику), иначе
следующие запуски подхватили бы устаревшие лимиты, а манифесты прогонов
показывали бы не те числа, что реально применены к контейнерам.
"""
rendered = render_stand_env(config)
STAND_ENV.write_text(rendered)
values = {
line.split('=', 1)[0]: line.split('=', 1)[1]
for line in rendered.splitlines()
if '=' in line and not line.startswith('#')
}
write_json(STAND_STATE, values)
return config
@@ -229,12 +239,44 @@ def wait_for_lb(timeout: float = 120) -> None:
raise SystemExit(f'stand did not become ready within {timeout}s: {last}')
def container_ids(service: str = 'api') -> list[str]:
def lb_backends_up() -> int:
"""Число backend-слотов LB в состоянии UP (без строк FRONTEND/BACKEND)."""
try:
with urllib.request.urlopen(LB_STATS_URL, timeout=3) as response:
text = response.read().decode('utf-8', 'replace')
except OSError:
return 0
lines = text.splitlines()
if lines and lines[0].startswith('#'):
lines[0] = lines[0].lstrip('#').lstrip()
return sum(
1
for row in csv.DictReader(lines)
if row.get('pxname') == 'api'
and re.match(r'^api\d+$', row.get('svname', ''))
and row.get('status') == 'UP'
)
def wait_for_replicas(expected: int, timeout: float = 180) -> list[str]:
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
mapping = replica_map()
if len(mapping) >= expected and lb_backends_up() >= expected:
return sorted(mapping)
time.sleep(1)
raise SystemExit(
f'ожидалось {expected} реплик, видно {len(replica_map())} контейнеров и {lb_backends_up()} UP-слотов LB'
)
def container_ids(service: str = 'api', *, include_stopped: bool = False) -> list[str]:
result = run_command(
[
'docker',
'ps',
'-q',
*(['-a'] if include_stopped else []),
'--filter',
f'label=com.docker.compose.project={PROJECT}',
'--filter',
@@ -727,13 +769,18 @@ def k6_run(script: str, label: str, env: dict[str, str], timeout: float) -> dict
def load_env(profile: str, mode: str, spread: str, label: str) -> dict[str, str]:
return {
env = {
'BASE_URL': 'http://haproxy:8080',
'PROFILE': spread,
'MODE': mode,
'CHATS': str(CHATS),
'LABEL': label,
}
if os.environ.get('LAB3_MAX_VUS'):
env['MAX_VUS'] = os.environ['LAB3_MAX_VUS']
if os.environ.get('LAB3_PRE_VUS'):
env['PRE_VUS'] = os.environ['LAB3_PRE_VUS']
return env
def run_measured(
@@ -821,6 +868,12 @@ def write_raw(
'dataset': dataset_size(),
'versions': image_versions(),
'host': {'cpus': bench_cpus(), 'background': host_background()},
'generator': {
'cpus': stand.get('LOADGEN_CPUS'),
'memory': stand.get('LOADGEN_MEMORY'),
'max_vus': os.environ.get('LAB3_MAX_VUS', '200'),
'pre_vus': os.environ.get('LAB3_PRE_VUS', '60'),
},
'commit': run_command(['git', 'rev-parse', 'HEAD'], check=False).stdout.strip(),
'quiesce': read_json(QUIESCE_STATE, None),
'phases': phases,
@@ -1111,10 +1164,13 @@ def cmd_check(args) -> None:
print(json.dumps({'replicas': replica_map(), 'haproxy': haproxy_stats(Sampler()._haproxy() or [])}, ensure_ascii=False, indent=1))
elif args.what == 'idempotency':
LEVEL4_DIR.mkdir(parents=True, exist_ok=True)
result = run_command(
['npx', 'vitest', 'run', '--config', './vitest.config.e2e.ts', '-t', 'idempotency'],
check=False,
timeout=600,
result = subprocess.run(
['npm', 'run', 'test:e2e', '--', '-t', 'idempotency'],
cwd=ROOT / 'app',
capture_output=True,
text=True,
timeout=900,
env={**os.environ, 'API_BASE_URL': BASE_URL},
)
output = result.stdout + result.stderr
(LEVEL4_DIR / 'idempotency-concurrency.txt').write_text(output, encoding='utf-8')
@@ -1131,6 +1187,14 @@ def cmd_run(args) -> None:
overrides['API_REPLICAS'] = str(args.replicas)
if args.pool:
overrides['DATABASE_POOL_MAX'] = str(args.pool)
if args.loadgen_cpus:
overrides['LOADGEN_CPUS'] = str(args.loadgen_cpus)
if args.lb_cpus:
overrides['LB_CPUS'] = str(args.lb_cpus)
if args.api_total_cpus:
overrides['API_TOTAL_CPUS'] = str(args.api_total_cpus)
if args.pg_cpus:
overrides['PG_CPUS'] = str(args.pg_cpus)
ensure_stand(overrides)
profile = args.profile
ladder = [int(value) for value in args.ladder.split(',')] if args.ladder else None
@@ -1183,10 +1247,21 @@ def report_series(profile: str, prefix: str) -> None:
write_markdown(TRACK1_DIR / f'summary-live-{profile}.md', f'Текущие агрегаты {profile}', lines)
def configuration_key(label: str) -> str:
"""Ключ конфигурации: метки вида <профиль>#<конфигурация>#rep<N>.
Без второго сегмента повторные прогоны разных конфигураций слились бы в одну
таблицу (например, все N серии A), а A/B-стороны 'ab#A'/'ab#B' — в одну
группу 'ab'.
"""
parts = label.split('#')
return '#'.join(parts[:2]) if len(parts) > 1 else parts[0]
def group_configurations(labels: list[str]) -> dict[str, list[str]]:
groups: dict[str, list[str]] = {}
for label in labels:
groups.setdefault(label.split('#')[0], []).append(label)
groups.setdefault(configuration_key(label), []).append(label)
return {key: sorted(value) for key, value in sorted(groups.items())}
@@ -1219,11 +1294,24 @@ def cmd_growth(args) -> None:
],
}
log(f'серия роста {args.series} на темпе {rate} req/s (80% от колена {args.base_profile})')
# Каждая точка отличается от базовой конфигурации ровно одним ресурсом:
# остальные значения прибиты к базовым, иначе после точки «API x2» следующий
# ресурс мерился бы уже с удвоенным бюджетом API.
baseline = {
'API_REPLICAS': '4',
'API_TOTAL_CPUS': str(DEFAULT_STAND['API_TOTAL_CPUS']),
'PG_CPUS': str(DEFAULT_STAND['PG_CPUS']),
'DATABASE_POOL_MAX': str(DEFAULT_STAND['DATABASE_POOL_MAX']),
'LB_CPUS': str(DEFAULT_STAND['LB_CPUS']),
}
for point in points[args.series]:
overrides = {'API_REPLICAS': '4', **{key: value for key, value in point.items() if key != 'label'}}
overrides = {
**baseline,
**{key: value for key, value in point.items() if key != 'label'},
}
ensure_stand(overrides)
run_measured(
f'growth#{point["label"]}',
f'growth#{point["label"]}{args.suffix}',
args.base_profile,
rate=rate,
duration=args.duration,
@@ -1245,12 +1333,13 @@ class MessageProbe(threading.Thread):
self.stop_event = threading.Event()
self.samples: list[dict] = []
self.confirmed: list[dict] = []
self.started_monotonic = time.monotonic()
def run(self) -> None:
import uuid
sequence = 0
started = time.monotonic()
started = self.started_monotonic
while not self.stop_event.is_set():
sequence += 1
key = uuid.uuid4().hex
@@ -1282,10 +1371,11 @@ def replica_ip(container: str) -> str:
def cmd_failover(args) -> None:
replicas = replica_map()
targets = sorted(replicas) if args.replicas == 'all' else [args.replicas]
config = load_stand_config()
ensure_stand({'API_REPLICAS': str(len(replicas))})
expected = int(config['API_REPLICAS'])
ensure_stand({'API_REPLICAS': str(expected)})
replicas = wait_for_replicas(expected)
targets = replicas if args.replicas == 'all' else [args.replicas]
results = []
for target in targets:
results.append(failover_once(target, args, config))
@@ -1294,10 +1384,19 @@ def cmd_failover(args) -> None:
def failover_once(target: str, args, config: dict) -> dict:
if target not in replica_map():
log(f'{target} не запущена: восстанавливаю реплику')
"""Один цикл: нагрузка -> остановка реплики -> возврат -> проверка истории.
Проба идёт постоянно и повторяет неопределённый POST тем же ключом, поэтому
«потерь» и «дублей» в истории быть не должно. Окно реального отсутствия
реплики считается от выхода контейнера (docker stop возвращает управление
уже после остановки), а не от вызова команды: дрейн длиной DRAIN_DELAY_MS
специально переживает обнаружение отказа LB и не должен выглядеть отказом.
"""
if target not in replica_map() or lb_backends_up() < len(replica_map()):
log(f'{target} не запущена или LB ещё не видит все реплики: восстанавливаю')
run_command(['scripts/start-replica.sh'])
wait_for_lb()
wait_for_replicas(len(replica_map()) or int(config['API_REPLICAS']))
if target not in replica_map():
raise SystemExit(f'replica {target} did not come back')
container = replica_map()[target]['container']
@@ -1307,15 +1406,16 @@ def failover_once(target: str, args, config: dict) -> dict:
alice = client.register(f'failover{target[:4]}')
chat = client.create_chat(alice['token'], [alice['id']], f'failover {target}')
load_seconds = int(args.pre + args.hold + 30)
label = f'failover#{target}'
env = {
**load_env('p-b', 'write', 'spread', label),
'RATE': str(args.rate),
'DURATION': str(args.duration),
'DURATION': str(load_seconds),
}
sampler = Sampler().start()
load = subprocess.Popen(
[*COMPOSE, '--profile', 'load', 'run', '--rm', '--no-deps', *sum((['-e', f'{k}={v}'] for k, v in env.items()), []), 'loadgen', 'run', '/load/write-steady.js'],
[*COMPOSE, '--profile', 'load', 'run', '--rm', '--no-deps', *sum((['-e', f'{key}={value}'] for key, value in env.items()), []), 'loadgen', 'run', '/load/write-steady.js'],
cwd=ROOT,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL,
@@ -1326,45 +1426,41 @@ def failover_once(target: str, args, config: dict) -> dict:
started = now_iso()
time.sleep(args.pre)
stop_moment = time.monotonic()
stop = run_command(
['scripts/stop-one.sh'],
check=False,
env={'TARGET_INSTANCE_ID': target},
timeout=30,
)
command_moment = time.monotonic()
stop = run_command(['scripts/stop-one.sh'], check=False, env={'TARGET_INSTANCE_ID': target}, timeout=30)
exit_moment = time.monotonic()
stop_at = now_iso()
first_success = None
while time.monotonic() - stop_moment < args.duration - args.pre:
successes = [sample for sample in list(probe.samples) if sample['t'] > 0 and sample.get('ok')]
if any(sample['t'] > (stop_moment - probe_start(probe)) for sample in successes):
first_success = round(time.monotonic() - stop_moment, 2)
first_success_after_exit = None
deadline = time.monotonic() + 30
while time.monotonic() < deadline:
exit_offset = probe_offset(probe, exit_moment)
if any(sample.get('ok') and sample['t'] >= exit_offset for sample in list(probe.samples)):
first_success_after_exit = round(probe_offset(probe, time.monotonic()), 2)
break
time.sleep(0.1)
time.sleep(max(0.0, args.hold))
time.sleep(args.hold)
restore_moment = time.monotonic()
restore_at = now_iso()
run_command(['scripts/start-replica.sh'])
recovered = None
deadline = time.monotonic() + 60
deadline = time.monotonic() + 90
while time.monotonic() < deadline:
instances = set()
for _ in range(6):
response = client.call('GET', '/api/v1/users/me', token=alice['token'])
instances.add(header(response['headers'], 'X-Instance-Id'))
if len(instances) >= 2:
recovered = round(time.monotonic() - stop_moment, 2)
seen = {
header(client.call('GET', '/api/v1/users/me', token=alice['token'])['headers'], 'X-Instance-Id')
for _ in range(6)
}
if len(seen) >= 2:
recovered = round(time.monotonic() - restore_moment, 2)
break
time.sleep(0.5)
remaining = max(0.0, args.duration - (time.monotonic() - stop_moment) - args.pre)
time.sleep(min(remaining, 15))
probe.stop_event.set()
probe.join(timeout=10)
load.terminate()
try:
stdout, _ = load.communicate(timeout=120)
stdout, _ = load.communicate(timeout=load_seconds + 90)
except subprocess.TimeoutExpired:
load.kill()
stdout, _ = load.communicate()
probe.stop_event.set()
probe.join(timeout=15)
samples = sampler.stop()
finished = now_iso()
@@ -1378,53 +1474,86 @@ def failover_once(target: str, args, config: dict) -> dict:
if 'steps' in candidate:
summary = candidate
break
history = client.history(alice['token'], chat)
texts = [item['text'] for item in history]
duplicates = sorted({text for text in texts if texts.count(text) > 1})
missing = [item['text'] for item in probe.confirmed if item['text'] not in texts]
lb = haproxy_stats(samples)
detection = None
for name, server in lb.items():
if address in server['addresses']:
for transition in server['transitions']:
if transition['status'] != 'UP':
detection = transition['t']
break
command_offset = probe_offset(probe, command_moment)
exit_offset = probe_offset(probe, exit_moment)
outage_start = first_success_after_exit if first_success_after_exit is None else exit_offset
last_offset = probe.samples[-1]['t'] if probe.samples else exit_offset
phases = {
'stop_at': stop_at,
'stop_exit': stop.returncode,
'first_success_after_stop_s': first_success,
'stop_command_at': stop_at,
'stop_exit_code': stop.returncode,
'stop_command_took_s': round(exit_moment - command_moment, 2),
'first_success_after_exit_s': (
round(first_success_after_exit - exit_offset, 2) if first_success_after_exit is not None else None
),
'restore_at': restore_at,
'second_replica_observed_s': recovered,
'lb_down_at': detection,
'replica_rejoined_s': recovered,
'lb_down_at': lb_down_time(samples, address),
'probe_offsets': {
'stop_command': round(command_offset, 2),
'container_exit': round(exit_offset, 2),
'restore_command': round(probe_offset(probe, restore_moment), 2),
'last_sample': round(last_offset, 2),
},
}
if summary:
write_raw(label, summary, samples, config, started, finished, phases, sampler.errors)
failures = [sample for sample in probe.samples if not sample.get('ok')]
result = {
'instance': target,
'container': container,
'address': address,
'rate': args.rate,
'duration_s': args.duration,
'phases': phases,
'probe': {
'attempts': len(probe.samples),
'successes': sum(1 for sample in probe.samples if sample.get('ok')),
'failures': sum(1 for sample in probe.samples if not sample.get('ok')),
'rps_before': phase_rps(probe.samples, 0, probe_start(probe) + args.pre - probe_start(probe)),
'failures': len(failures),
'confirmed': len(probe.confirmed),
'rps_before': phase_rps(probe.samples, 0.0, command_offset),
'rps_while_stopped': phase_rps(probe.samples, exit_offset, outage_start),
'rps_after': phase_rps(probe.samples, outage_start, last_offset),
'errors_while_stopped': sum(
1 for sample in failures if exit_offset <= sample['t'] <= outage_start
),
'timeline': [[sample['t'], 1 if sample.get('ok') else 0] for sample in probe.samples],
},
'duplicates': duplicates,
'missing_confirmed': missing,
'haproxy': lb,
'k6': {'achieved_rps': summary['steps'][0]['achieved_rps'] if summary else None, 'failed': summary['steps'][0]['failed'] if summary else None},
'haproxy': haproxy_stats(samples),
'k6': {
'achieved_rps': summary['steps'][0]['achieved_rps'] if summary else None,
'failed': summary['steps'][0]['failed'] if summary else None,
'dropped': summary.get('dropped_iterations') if summary else None,
},
}
log(f'failover {target}: падение обнаружено, восстановление {recovered}s, дубли: {len(duplicates)}, потеряно: {len(missing)}')
log(
f'failover {target}: контейнер остановлен через {phases["stop_command_took_s"]}s, '
f'первый успех после остановки через {phases["first_success_after_exit_s"]}s, '
f'реплика вернулась через {recovered}s, дубли {len(duplicates)}, потеряно {len(missing)}'
)
return result
def probe_start(probe: MessageProbe) -> float:
return probe.samples[0]['t'] if probe.samples else 0.0
def probe_offset(probe: MessageProbe, moment: float) -> float:
"""Переводит момент wall-clock в шкалу времени сэмплов пробы."""
if not probe.samples:
return 0.0
return probe.samples[0]['t'] + (moment - probe.started_monotonic)
def lb_down_time(samples: list[dict], address: str) -> str | None:
for record in samples:
if record.get('source') != 'haproxy' or record.get('server') in ('FRONTEND', 'BACKEND'):
continue
if address in (record.get('addr') or '') and record.get('status') not in ('UP',):
return record['t']
return None
def phase_rps(samples: list[dict], start: float, end: float) -> float:
@@ -1435,22 +1564,54 @@ def phase_rps(samples: list[dict], start: float, end: float) -> float:
def write_failover_evidence(results: list[dict]) -> None:
write_json(LEVEL4_DIR / 'failover-sweep.json', results)
lines = table(
['реплика', 'контейнер', 'попыток', 'успешных', 'ошибок', 'первый успех, s', 'вторая реплика, s', 'дубли', 'потери'],
[
'реплика',
'контейнер',
'попыток пробы',
'успешных',
'ошибок в отказе',
'остановка контейнера, s',
'первый успех после остановки, s',
'реплика вернулась, s',
'LB DOWN',
'RPS до',
'RPS в отказе',
'RPS после',
'k6 RPS',
'k6 ошибок',
'дубли',
'потери',
],
[
[
result['instance'][:12],
result['container'][:12],
result['probe']['attempts'],
result['probe']['successes'],
result['probe']['failures'],
result['phases']['first_success_after_stop_s'],
result['phases']['second_replica_observed_s'],
result['probe']['errors_while_stopped'],
result['phases']['stop_command_took_s'],
result['phases']['first_success_after_exit_s'],
result['phases']['replica_rejoined_s'],
(result['phases']['lb_down_at'] or '-')[11:19],
result['probe']['rps_before'],
result['probe']['rps_while_stopped'],
result['probe']['rps_after'],
result['k6']['achieved_rps'],
result['k6']['failed'],
len(result['duplicates']),
len(result['missing_confirmed']),
]
for result in results
],
)
lines += [
'',
'Проба: последовательные POST с интервалом 0.2 s, при неопределённом результате '
'повтор с тем же Idempotency-Key (как у реального клиента). Окно отсутствия реплики '
'считается от выхода контейнера до первого успешного ответа после него; дрейн перед '
'остановкой специально переживает обнаружение отказа LB, поэтому клиент не обязан '
'видеть ошибки. Потери и дубли проверяются по истории чата.',
]
write_markdown(LEVEL4_DIR / 'failover-sweep.md', 'Отказ каждой реплики под нагрузкой', lines)
@@ -1459,7 +1620,7 @@ def cmd_rolling(args) -> None:
replicas = int(config['API_REPLICAS'])
build_id = args.build_id or datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')
before = replica_map()
migrate_before = inspect(container_ids('migrate')[0], '{{.State.StartedAt}}') if container_ids('migrate') else None
migrate_before = inspect(container_ids('migrate', include_stopped=True)[0], '{{.State.StartedAt}}')
log(f'сборка образа {config["API_IMAGE"]} с BUILD_ID={build_id}')
build = run_command(
['docker', 'build', '--build-arg', f'BUILD_ID={build_id}', '-t', config['API_IMAGE'], '.'],
@@ -1488,13 +1649,15 @@ def cmd_rolling(args) -> None:
steps = []
for step in range(replicas):
current = replica_map()
target = sorted(current)[step % len(current)]
known = set(current)
# Меняем самую «старую» реплику: только что созданная видна как самая молодая.
target = sorted(current, key=lambda instance: current[instance]['started_at'])[0]
container = current[target]['container']
old_build = app_build_id(container)
run_command(['docker', 'stop', '--time', '15', container], check=False, timeout=60)
run_command(['docker', 'rm', container], check=False, timeout=60)
compose('up', '-d', '--no-deps', '--no-recreate', '--scale', f'api={replicas}', 'api', timeout=600)
new_instance, new_container = wait_for_replica_count(replicas, exclude=target)
new_instance, new_container = wait_for_new_replica(replicas, known)
new_build = app_build_id(new_container)
steps.append(
{
@@ -1510,27 +1673,30 @@ def cmd_rolling(args) -> None:
)
log(f'rolling {step + 1}/{replicas}: {target[:12]} ({old_build}) -> {new_instance[:12]} ({new_build})')
time.sleep(args.pause)
summary = None
if load is not None:
try:
stdout, _ = load.communicate(timeout=max(30, args.duration))
except subprocess.TimeoutExpired:
load.terminate()
try:
stdout, _ = load.communicate(timeout=60)
except subprocess.TimeoutExpired:
load.kill()
stdout, _ = load.communicate()
probe.stop_event.set()
probe.join(timeout=10)
samples = sampler.stop()
summary = None
if load is not None:
load.terminate()
try:
stdout, _ = load.communicate(timeout=120)
except subprocess.TimeoutExpired:
load.kill()
stdout, _ = load.communicate()
for line in reversed((stdout or '').splitlines()):
if line.strip().startswith('{'):
try:
candidate = json.loads(line)
except ValueError:
continue
if 'steps' in candidate:
summary = candidate
break
migrate_after = inspect(container_ids('migrate')[0], '{{.State.StartedAt}}') if container_ids('migrate') else None
for line in reversed((stdout or '').splitlines()):
if line.strip().startswith('{'):
try:
candidate = json.loads(line)
except ValueError:
continue
if 'steps' in candidate:
summary = candidate
break
migrate_after = inspect(container_ids('migrate', include_stopped=True)[0], '{{.State.StartedAt}}')
failures = [sample for sample in probe.samples if not sample.get('ok')]
server_failures = [sample for sample in failures if 500 <= int(sample.get('status') or 0) < 600]
finished = now_iso()
@@ -1575,16 +1741,22 @@ def app_build_id(container: str) -> str:
return result.stdout.strip() or 'unknown'
def wait_for_replica_count(replicas: int, exclude: str, timeout: float = 120) -> tuple[str, str]:
def wait_for_new_replica(replicas: int, known: set[str], timeout: float = 180) -> tuple[str, str]:
"""Ждёт появления НОВОЙ реплики (не из known) в состоянии healthy."""
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
mapping = replica_map()
if len(mapping) >= replicas:
for instance, info in sorted(mapping.items()):
if instance != exclude:
fresh = {instance: info for instance, info in mapping.items() if instance not in known}
if len(mapping) >= replicas and fresh:
for instance, info in sorted(fresh.items()):
status = inspect(info['container'], '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}')
if status == 'healthy':
return instance, info['container']
time.sleep(1)
raise SystemExit(f'replica count did not reach {replicas} within {timeout}s')
raise SystemExit(
f'новая реплика не появилась healthy за {timeout}s (контейнеров {len(replica_map())}, '
f'новых {len({i for i in replica_map() if i not in known})})'
)
def cmd_ab(args) -> None:
@@ -1597,12 +1769,23 @@ def cmd_ab(args) -> None:
report_ab(args)
def report_ab(args) -> None:
def report_ab(args=None) -> None:
labels = [label for label in raw_labels() if label.startswith('ab#')]
groups = group_configurations(labels)
lines = []
verdicts = []
series_by_side = {side: summarise_series(groups.get(side, [])) for side in ('A', 'B')}
series_by_side = {
side: summarise_series(groups.get(f'ab#{side}', [])) for side in ('A', 'B')
}
images = {
side: (getattr(args, side.lower(), None) if args else None) for side in ('A', 'B')
}
for side in ('A', 'B'):
if not images[side] and groups.get(f'ab#{side}'):
manifest = read_json(
RAW_DIR / f'{groups[f"ab#{side}"][-1]}.manifest.json', {}
)
images[side] = (manifest.get('stand') or {}).get('API_IMAGE')
for rate in sorted({row['rate'] for row in series_by_side['A']['rows']}):
row_a = next((row for row in series_by_side['A']['rows'] if row['rate'] == rate), None)
row_b = next((row for row in series_by_side['B']['rows'] if row['rate'] == rate), None)
@@ -1648,7 +1831,14 @@ def report_ab(args) -> None:
'',
'Правило подтверждения: медиана меняется ≥5 % и диапазоны min/max повторов не перекрываются.',
]
write_json(TRACK1_DIR / 'ab-verdict.json', {'verdicts': verdicts, 'ceiling': {side: series_by_side[side]['ceiling_rps'] for side in ('A', 'B')}, 'images': {'A': args.before, 'B': args.after}})
write_json(
TRACK1_DIR / 'ab-verdict.json',
{
'verdicts': verdicts,
'ceiling': {side: series_by_side[side]['ceiling_rps'] for side in ('A', 'B')},
'images': images,
},
)
write_markdown(TRACK1_DIR / 'summary-ab.md', 'A/B: подтверждённое улучшение', lines)
@@ -1687,8 +1877,8 @@ def cmd_analyze(args) -> None:
analyse_series_a(groups, labels)
analyse_diagnostics(groups, labels)
analyse_growth(groups, labels)
if groups.get('A') or groups.get('B'):
report_ab(None, None)
if groups.get('ab#A') or groups.get('ab#B'):
report_ab()
make_graphs(groups, labels)
log('analyze: таблицы и графики обновлены')
@@ -2082,10 +2272,10 @@ def make_graphs(groups: dict, labels: list[str]) -> None:
figure.savefig(GRAPH_DIR / 'growth.png', dpi=120)
plt.close(figure)
if groups.get('A') and groups.get('B'):
if groups.get('ab#A') and groups.get('ab#B'):
figure, axes = plt.subplots(figsize=(9, 5))
series_a = summarise_series(groups['A'])
series_b = summarise_series(groups['B'])
series_a = summarise_series(groups['ab#A'])
series_b = summarise_series(groups['ab#B'])
rates = [row['rate'] for row in series_a['rows']]
positions = list(range(len(rates)))
axes.bar([p - 0.2 for p in positions], [row['achieved_rps'] for row in series_a['rows']], width=0.4, label='A (до)')
@@ -2135,6 +2325,25 @@ def plot_container_cpu(plt, label: str) -> None:
# ---------------------------------------------------------------- оркестрация трека
def cmd_watch(args) -> None:
"""Сэмплер без нагрузки: наблюдает стенд N секунд и пишет jsonl.gz.
Нужен там, где нагрузку создаёт внешний сценарий (публичный failover-тест,
rolling update): переходы статусов LB получают отметки времени.
"""
sampler = Sampler().start()
try:
time.sleep(args.seconds)
finally:
samples = sampler.stop()
out = Path(args.out)
out.parent.mkdir(parents=True, exist_ok=True)
with gzip.open(out, 'wt', encoding='utf-8') as handle:
for record in samples:
handle.write(json.dumps(record, ensure_ascii=False) + '\n')
print(json.dumps({'out': str(out), 'samples': len(samples), 'errors': sampler.errors}, ensure_ascii=False))
def cmd_quiesce(args) -> None:
result = run_command(['scripts/quiesce.sh', args.action], check=False, timeout=300)
print(result.stdout + result.stderr)
@@ -2210,6 +2419,10 @@ def build_parser() -> argparse.ArgumentParser:
run.add_argument('--duration', type=int, help='длительность полки, s')
run.add_argument('--replicas', type=int)
run.add_argument('--pool', type=int, help='DATABASE_POOL_MAX на реплику')
run.add_argument('--loadgen-cpus', type=float, help='лимит CPU генератора (контингенция: k6 упёрся в квоту)')
run.add_argument('--lb-cpus', type=float, help='лимит CPU HAProxy')
run.add_argument('--api-total-cpus', type=float, help='суммарный бюджет CPU API (делится на реплики)')
run.add_argument('--pg-cpus', type=float, help='лимит CPU PostgreSQL')
run.add_argument('--mode', choices=['write', 'read'])
run.add_argument('--spread', choices=['spread', 'hot'])
run.add_argument('--no-warmup', action='store_true')
@@ -2231,6 +2444,7 @@ def build_parser() -> argparse.ArgumentParser:
growth.add_argument('--duration', type=int, default=60)
growth.add_argument('--base-profile', default='p-a')
growth.add_argument('--no-warmup', action='store_true')
growth.add_argument('--suffix', default='', help='суффикс метки: различает прогоны одной точки на разных темпах')
growth.set_defaults(func=cmd_growth)
failover = sub.add_parser('failover', help='фазовый драйвер отказа реплики')
@@ -2261,6 +2475,11 @@ def build_parser() -> argparse.ArgumentParser:
analyze = sub.add_parser('analyze', help='агрегаты и графики из raw')
analyze.set_defaults(func=cmd_analyze)
watch = sub.add_parser('watch', help='сэмплер без нагрузки: наблюдение за стендом')
watch.add_argument('--seconds', type=float, default=30)
watch.add_argument('--out', required=True)
watch.set_defaults(func=cmd_watch)
quiesce = sub.add_parser('quiesce', help='фон хоста: up/down/status')
quiesce.add_argument('action', choices=['up', 'down', 'status'])
quiesce.set_defaults(func=cmd_quiesce)
+8 -1
View File
@@ -20,7 +20,13 @@ const LOAD_USERS = 3;
// Бюджет VU: на 1100 req/s при p95 около 25 ms достаточно около 30 активных VU;
// 60 предвыделенных и 200 максимальных оставляют запас, чтобы узкое место
// оказалось на сервере, а не в генераторе.
export const VUS = { preAllocated: 60, max: 200 };
// Бюджет VU: на 1100 req/s при p95 около 25 ms достаточно около 30 активных VU.
// Значения переопределяются извне (PRE_VUS/MAX_VUS): на пути чтения генератор
// упирался в 200 VU раньше, чем в CPU, и потолок измерялся бы как потолок k6.
export const VUS = {
preAllocated: Number(__ENV.PRE_VUS || 60),
max: Number(__ENV.MAX_VUS || 200),
};
export function ratesFromEnv(fallback) {
const raw = __ENV.LADDER;
@@ -232,6 +238,7 @@ export function summaryJson(data, metrics, rates, kind, stepSeconds) {
iterations: data.metrics.iterations?.values?.count ?? 0,
dropped_iterations: data.metrics.dropped_iterations?.values?.count ?? 0,
vus_max: data.metrics.vus_max?.values?.value ?? 0,
vus_configured: VUS,
http_req_duration_p95: round(global['p(95)'] ?? 0, 2),
checks: {
passes: data.metrics.checks?.values?.passes ?? 0,