forked from mtusi2026/mtusi2026lab3
354 lines
20 KiB
Python
Executable File
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)
|