Files
mtusi2026lab3/scripts/failure-detection.py
2026-11-05 17:56:30 +03:00

354 lines
20 KiB
Python
Executable File

#!/usr/bin/env python3
"""Как LB исключает реплику: stop, kill, pause, idle_kill, graceful, notready, deps.
Стенд должен быть запущен с двумя репликами. Реплики останавливаются и восстанавливаются,
данные только синтетические. Запуск и сохранение результата: scripts/failure-detection-evidence.sh"""
# Запуск отдельных сценариев: python3 scripts/failure-detection.py stop kill
# Каждый сценарий печатает одну или несколько строк JSON. Токены и пароли не печатаются.
import collections
import json
import pathlib
import socket
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.request
import uuid
# Корень проекта: docker compose должен запускаться из него.
ROOT = str(pathlib.Path(__file__).resolve().parents[1])
# Публичный адрес LB. Задан жёстко, другой порт здесь не поддерживается.
BASE = 'http://localhost:8080'
# Клиент API из публичных тестов: нужен сценарию graceful, чтобы создать пользователей и чат.
sys.path.insert(0, ROOT + '/tests')
from client import Client # noqa: E402
# Выполнить команду и вернуть её stdout. check=True: при ненулевом коде выхода будет исключение.
def sh(*a, check=True):
return subprocess.run(a, cwd=ROOT, capture_output=True, text=True, check=check).stdout.strip()
# То же для docker compose с настройками стенда.
def dc(*a, check=True):
return sh('docker', 'compose', '--env-file', '.env', *a, check=check)
# Состояния всех слотов бэкенда api по мнению LB: "UP", "UP 1/2", "DOWN 1/2", "DOWN", "MAINT".
# Берутся из CSV-статистики HAProxy, поле status имеет индекс 17. Строка BACKEND — итог, а не реплика.
def states():
csv = dc('exec', '-T', 'lb', 'wget', '-qO-', 'http://127.0.0.1:8404/stats;csv', check=False)
return [l.split(',')[17] for l in csv.splitlines()
if l.startswith('api,') and l.split(',')[1] != 'BACKEND']
# Сколько реплик полностью работают: ни одной неудачной проверки подряд.
def fully_up():
return sum(1 for s in states() if s == 'UP')
# Сколько реплик ещё получают трафик. По этому числу измеряется момент вывода реплики.
def serving():
# "UP 1/2" (one failed check) still receives traffic, so it counts as serving.
return sum(1 for s in states() if s.startswith('UP') or s.startswith('NOLB'))
# Подождать до t секунд, пока LB не покажет ровно n полностью работающих реплик.
def wait_up(n, t=60):
end = time.monotonic() + t
while time.monotonic() < end:
if fully_up() == n:
return True
time.sleep(0.3)
return False
# ID работающих API-контейнеров.
def containers():
return dc('ps', '-q', 'api').split()
# Сценарии stop, kill, pause: отказ реплики под трафиком. Измеряет, когда LB её вывел,
# сколько ошибок получили клиенты и когда реплика ответила в последний раз.
def timing(mode, target_idx):
assert wait_up(2), 'LB does not see 2 replicas'
cid = containers()[target_idx]
# X-Instance-Id содержит короткий ID контейнера: так видно, кто обслужил запрос.
short = cid[:12]
results = []
stop = threading.Event()
# Клиент трафика: запрашивает /health/live через LB и записывает кортеж
# (время начала, длительность, код или тип ошибки, какая реплика ответила).
def worker():
while not stop.is_set():
t0 = time.monotonic()
try:
with urllib.request.urlopen(BASE + '/health/live', timeout=2) as r:
results.append((t0, time.monotonic() - t0, r.status, r.headers.get('X-Instance-Id')))
except urllib.error.HTTPError as e:
results.append((t0, time.monotonic() - t0, e.code, e.headers.get('X-Instance-Id')))
except Exception as e:
results.append((t0, time.monotonic() - t0, type(e).__name__, None))
time.sleep(0.02)
# 8 параллельных клиентов и 2,5 с работы до отказа.
threads = [threading.Thread(target=worker) for _ in range(8)]
[t.start() for t in threads]
time.sleep(2.5)
t_fail = time.monotonic()
cmd = {'stop': 'stop', 'kill': 'kill', 'pause': 'pause'}[mode]
# В отдельном потоке: docker stop блокируется до конца завершения реплики, а засекать
# вывод из LB нужно уже сейчас.
threading.Thread(target=lambda: sh('docker', cmd, cid, check=False)).start()
# Опрашиваем LB до 15 с: время, через которое осталась одна обслуживающая реплика.
t_down = None
end = time.monotonic() + 15
while time.monotonic() < end:
if serving() == 1:
t_down = time.monotonic() - t_fail
break
time.sleep(0.03)
# Ещё 6 с трафика: запросы, зависшие на реплике, успевают завершиться или получить таймаут.
time.sleep(6)
stop.set()
[t.join() for t in threads]
# В расчёт идут только запросы, начатые после отказа. Ошибка — любой ответ, кроме 200.
after = [r for r in results if r[0] >= t_fail]
bad = [r for r in after if r[2] != 200]
target_hits = [r[0] - t_fail for r in after if r[3] == short]
last_err = max((r[0] + r[1] - t_fail for r in bad), default=0)
out = {
'mode': mode, 'lb_excluded_after_s': round(t_down, 2) if t_down else None,
'requests': len(after), 'errors': dict(collections.Counter(str(r[2]) for r in bad)),
'last_error_at_s': round(last_err, 2),
'last_served_by_target_s': round(max(target_hits), 2) if target_hits else None,
}
print(json.dumps(out, ensure_ascii=False), flush=True)
# Восстановление: приостановленный контейнер размораживается, остановленный запускается заново.
if mode == 'pause':
sh('docker', 'unpause', cid)
else:
dc('up', '-d', '--wait', check=False)
assert wait_up(2), 'not recovered'
return out
# Сценарий graceful: SIGTERM при открытых запросах. Запросы завершаются, порт закрывается после drain.
def graceful():
"""Requests in flight across SIGTERM must finish; the listener must close after drain."""
assert wait_up(2)
c = Client(BASE, timeout=5)
alice, bob, eve, chat = c.bootstrap()
cid = containers()[0]
short = cid[:12]
# Адрес реплики внутри сети Docker: к ней обращаемся напрямую, минуя балансировку.
ip = sh('docker', 'inspect', '-f', '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}', cid)
# 8 POST через LB с заголовками и только первыми 5 байтами тела. Сервер ждёт остаток,
# поэтому запросы остаются открытыми, сколько нужно. Round-robin делит их между репликами.
socks = []
for i in range(8):
key = uuid.uuid4().hex
body = json.dumps({'text': 'inflight-' + key}).encode()
s = socket.create_connection(('localhost', 8080), timeout=30)
head = ('POST /api/v1/chats/%s/messages HTTP/1.1\r\nHost: x\r\nAuthorization: Bearer %s\r\n'
'Content-Type: application/json\r\nIdempotency-Key: %s\r\nContent-Length: %d\r\n'
'Connection: close\r\n\r\n' % (chat['id'], alice['token'], key, len(body))).encode()
s.sendall(head + body[:5])
socks.append((s, body, key))
time.sleep(0.3)
# SIGTERM одной реплике. В отдельном потоке, потому что docker stop блокируется.
t0 = time.monotonic()
stopper = threading.Thread(target=lambda: sh('docker', 'stop', cid, check=False))
stopper.start()
# While requests are open: is the listener closed for new connections after drain?
# В течение 5 с спрашиваем readiness реплики напрямую из контейнера LB и записываем
# (время, успех, текст ошибки wget): так видно сначала 503, затем отказ в соединении.
probe = []
while time.monotonic() - t0 < 5:
r = subprocess.run(['docker', 'compose', '--env-file', '.env', 'exec', '-T', 'lb', 'wget', '-qO-', '-T', '1',
'http://%s:8080/health/ready' % ip], cwd=ROOT, capture_output=True, text=True)
probe.append((round(time.monotonic() - t0, 2), r.returncode == 0, r.stderr.strip()[:120]))
time.sleep(0.25)
# Finish bodies 5 s after SIGTERM: past drain (3 s), inside shutdown timeout.
# Досылаем остаток тел и читаем ответы: достаём код и реплику, которая ответила.
res = []
for s, body, key in socks:
s.sendall(body[5:])
for s, body, key in socks:
data = b''
try:
while True:
part = s.recv(65536)
if not part:
break
data += part
except Exception as e:
data = repr(e).encode()
head = data.split(b'\r\n\r\n')[0].decode(errors='replace')
code = head.split(' ')[1] if ' ' in head else head
inst = [l.split(':', 1)[1].strip() for l in head.split('\r\n') if l.lower().startswith('x-instance-id')]
res.append((code, inst[0] if inst else None, key))
s.close()
stopper.join()
t_stop = time.monotonic() - t0
# Из проб: когда порт перестал принимать соединения и когда readiness стал отвечать 503.
closed_at = next((p[0] for p in probe if 'refused' in p[2] or 'timed out' in p[2]), None)
ready503_at = next((p[0] for p in probe if '503' in p[2]), None)
# Запросы именно на останавливаемой реплике: главное, что здесь проверяется.
on_target = [r for r in res if r[1] == short]
# Код выхода контейнера: 0 значит штатное завершение, а не SIGKILL по истечении срока.
insp = sh('docker', 'inspect', '-f', 'status={{.State.Status}} exit={{.State.ExitCode}}', cid)
# Какие этапы завершения есть в логе приложения.
p = subprocess.run(['docker', 'logs', '--tail', '30', cid], capture_output=True, text=True)
log = p.stdout + p.stderr
msgs = [m for m in ('shutdown signal received', 'http server draining', 'http server shutting down', 'server stopped cleanly') if m in log]
# Сверка с историей: каждый ответ 201 должен соответствовать сохранённому сообщению.
items = c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=100', actor=alice, schema='MessagePage')['json']['items']
texts = {m['text'] for m in items}
print(json.dumps({
'codes': dict(collections.Counter(r[0] for r in res)),
'inflight_on_stopped_replica': len(on_target),
'on_target_codes': dict(collections.Counter(r[0] for r in on_target)),
'confirmed_saved': sum(1 for r in res if r[0] == '201' and 'inflight-' + r[2] in texts),
'listener_closed_after_s': closed_at,
'ready_503_after_s': ready503_at, 'docker_stop_took_s': round(t_stop, 2),
'container': insp, 'log_sequence': msgs,
}, ensure_ascii=False), flush=True)
dc('up', '-d', '--wait', check=False)
assert wait_up(2), 'not recovered'
# Сценарий notready: появляется новый адрес с неудачным readiness. LB не должен слать на него
# трафик ни на миг, даже до первой проверки (за это отвечает init-state down в haproxy.cfg).
def notready():
"""A new address with a failing readiness: does the LB route traffic before any check passes?"""
assert wait_up(2)
name = 'lab3-notready-probe'
sh('docker', 'rm', '-f', name, check=False)
image = 'haproxy:3.2.9-alpine'
hits = collections.Counter()
stop = threading.Event()
# Клиент трафика запрашивает несуществующий путь: настоящая реплика вернёт 404,
# а поддельная вернёт 200 с текстом FAKE. Любой счётчик 'fake' означает провал.
def worker():
while not stop.is_set():
try:
with urllib.request.urlopen(BASE + '/fake-replica-marker.txt', timeout=2) as r:
hits['fake' if b'FAKE' in r.read() else 'other'] += 1
except urllib.error.HTTPError:
hits['real_404'] += 1
except Exception:
hits['error'] += 1
time.sleep(0.005)
threads = [threading.Thread(target=worker) for _ in range(8)]
[t.start() for t in threads]
time.sleep(1)
try:
# Поддельная реплика: отдельный HAProxy в сети стенда с DNS-именем api, поэтому LB находит
# её как новую реплику. На /health/ready отвечает 503, на всё остальное 200 FAKE.
cfg = ('defaults\n mode http\n timeout connect 1s\n timeout client 10s\n timeout server 10s\n'
'frontend f\n bind :8080\n'
' http-request return status 503 content-type text/plain string NOTREADY if { path /health/ready }\n'
' http-request return status 200 content-type text/plain string FAKE\n')
sh('docker', 'run', '-d', '--name', name, '--network', 'mtusi-lab3_default', '--network-alias', 'api',
'-e', 'CFG=' + cfg, '--entrypoint', 'sh', image, '-c',
'printf "%s" "$CFG" > /tmp/h.cfg && exec haproxy -f /tmp/h.cfg')
# 8 с записываем каждую смену состояний в LB; свободные слоты (MAINT) не учитываем.
end = time.monotonic() + 8
seen_states = []
while time.monotonic() < end:
st = [x for x in states() if not x.startswith('MAINT')]
if not seen_states or seen_states[-1] != st:
seen_states.append(st)
time.sleep(0.05)
# Защита от ложного успеха: поддельная реплика действительно работает и доступна,
# а значит, отсутствие трафика на ней заслуга LB, а не её поломка.
running = sh('docker', 'inspect', '-f', '{{.State.Running}}', name)
check_ready = dc('exec', '-T', 'lb', 'sh', '-c',
'wget -S -qO- -T 2 http://%s:8080/health/ready 2>&1 | head -1; wget -qO- -T 2 http://%s:8080/x' % ((sh('docker', 'inspect', '-f', '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}', name),) * 2), check=False)
assert running == 'true' and 'FAKE' in check_ready, 'probe replica is not serving: ' + running + ' ' + check_ready
print(json.dumps({'probe_serving': True, 'state_transitions': seen_states}), flush=True)
finally:
# Поддельный контейнер удаляется в любом случае, даже при неудачной проверке.
stop.set()
[t.join() for t in threads]
sh('docker', 'rm', '-f', name, check=False)
print(json.dumps({'requests_routed': dict(hits)}, ensure_ascii=False), flush=True)
assert wait_up(2, 30), 'not recovered'
# Сценарий idle_kill (или idle_<команда docker>): отказ без трафика. Срабатывают только активные
# проверки LB, поэтому время отражает настройки inter, fall и таймауты.
def idle(mode):
assert wait_up(2)
cid = containers()[0]
t0 = time.monotonic()
sh('docker', mode, cid)
while serving() != 1 and time.monotonic() - t0 < 15:
time.sleep(0.03)
print(json.dumps({'idle_' + mode + '_excluded_after_s': round(time.monotonic() - t0, 2)}), flush=True)
if mode == 'pause':
sh('docker', 'unpause', cid)
else:
dc('up', '-d', '--wait', check=False)
assert wait_up(2), 'not recovered'
# Сценарий deps: отказ общей зависимости. Реплики живы, но не готовы, поэтому LB выводит все.
def deps():
"""Readiness зависит от общего хранилища: без Valkey обе реплики выводятся, live остаётся 200."""
assert wait_up(2)
cid = containers()[0]
sh('docker', 'compose', '--env-file', '.env', 'stop', 'valkey')
# Время, через которое LB вывел все реплики.
t0 = time.monotonic()
while serving() != 0 and time.monotonic() - t0 < 15:
time.sleep(0.05)
excluded = round(time.monotonic() - t0, 2)
# Что видит клиент через LB: ожидается 503, так как рабочих реплик нет.
try:
urllib.request.urlopen(BASE + '/health/live', timeout=3)
via_lb = 200
except urllib.error.HTTPError as e:
via_lb = e.code
# Напрямую к реплике: live должен работать, а ready нет.
ip = sh('docker', 'inspect', '-f', '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}', cid)
probe = lambda p: subprocess.run(['docker', 'compose', '--env-file', '.env', 'exec', '-T', 'lb', 'wget', '-qO-', '-T', '3',
'http://%s:8080%s' % (ip, p)], cwd=ROOT, capture_output=True, text=True)
live, ready = probe('/health/live'), probe('/health/ready')
print(json.dumps({'valkey_stopped_all_replicas_excluded_after_s': excluded, 'live_via_lb': via_lb,
'replica_live_ok': live.returncode == 0, 'replica_ready_ok': ready.returncode == 0}), flush=True)
dc('up', '-d', '--wait', check=False)
# Отсчёт идёт после завершения up --wait, то есть это не полное время восстановления
# с момента запуска Valkey, а только остаток ожидания после него.
t0 = time.monotonic()
assert wait_up(2), 'not recovered'
print(json.dumps({'valkey_restored_replicas_back_after_s': round(time.monotonic() - t0, 2)}), flush=True)
# Сценарии выполняются в порядке аргументов.
for arg in sys.argv[1:]:
if arg == 'deps':
deps()
elif arg.startswith('idle_'):
# 3 повтора: idle_kill вызывает idle('kill').
for _ in range(3):
idle(arg[5:])
elif arg == 'graceful':
graceful()
elif arg == 'notready':
notready()
else:
# stop, kill или pause: 3 повтора, отказывают реплики 0, 1 и снова 0.
for i in (0, 1, 0):
timing(arg, i)