feat: add replicated messenger and reproducible lab3 stand

This commit is contained in:
2026-10-15 13:43:39 +03:00
parent 0ab3a341aa
commit 84dd7fec0a
106 changed files with 17235 additions and 24 deletions
+251
View File
@@ -0,0 +1,251 @@
#!/usr/bin/env python3
"""Операторские команды стенда лабы 3 (свои, не skeleton). Python 3.9+, stdlib.
python3 scripts/lab3.py instances [--base-url URL] [--requests 12]
вход одним синтетическим пользователем и серия GET /users/me с одним
токеном через LB: X-Instance-Id каждого ответа и итог по репликам
(шаг 1 сценария защиты);
python3 scripts/lab3.py lb-stats
слоты HAProxy рабочего стенда: адрес, состояние проверки, запросы в
полёте, всего, ошибки соединения, повторы, перенаправления;
python3 scripts/lab3.py failover-each [--base-url URL] [--replicas 2]
[--mode stop|kill]
make test-failover для каждой реплики по очереди: перед прогоном все
реплики возвращены (make replicas), тест останавливает реплику,
ответившую на его первую запись; если это реплика, которую уже
проверили, очередь LB сдвигается одним запросом и прогон
повторяется. Печатает docker compose ps до и после, строку
STOP_ONE_LOG и итог теста — это evidence «какой контейнер
действительно остановлен».
Пароль синтетического пользователя и токен живут только в памяти и не
печатаются. Работает с проектом compose репозитория (compose.yaml и .env).
"""
from __future__ import annotations
import argparse
import base64
import json
import os
import secrets
import subprocess
import sys
import tempfile
import time
import urllib.error
import urllib.request
from collections import Counter
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
LB_STATS = (
"exec 3<>/dev/tcp/127.0.0.1/8404 && "
"printf 'GET /stats;csv HTTP/1.0\\r\\n\\r\\n' >&3 && cat <&3"
)
STAT_FIELDS = ("addr", "status", "scur", "stot", "econ", "eresp", "wretr", "wredis")
def call(base: str, method: str, path: str, headers=None, body=None):
data = json.dumps(body).encode() if body is not None else None
request = urllib.request.Request(base + path, data=data, method=method)
for key, value in (headers or {}).items():
request.add_header(key, value)
if data is not None:
request.add_header("Content-Type", "application/json")
try:
with urllib.request.urlopen(request, timeout=10) as response:
return response.status, dict(response.headers), response.read()
except urllib.error.HTTPError as error:
return error.code, dict(error.headers), error.read()
def login(base: str) -> str:
username = "ops_" + secrets.token_hex(6)
password = secrets.token_urlsafe(18)
status, _, _ = call(
base,
"POST",
"/api/v1/users",
body={"username": username, "display_name": "Оператор", "password": password},
)
if status != 201:
raise SystemExit(f"register -> {status}")
basic = base64.b64encode(f"{username}:{password}".encode()).decode()
status, _, data = call(
base,
"POST",
"/api/v1/auth/sessions",
headers={"Authorization": "Basic " + basic},
)
if status != 201:
raise SystemExit(f"login -> {status}")
return json.loads(data)["token"]
def instances(args: argparse.Namespace) -> int:
token = login(args.base_url)
seen: Counter = Counter()
print(f"one session, {args.requests} x GET /api/v1/users/me via {args.base_url}")
for number in range(1, args.requests + 1):
status, headers, _ = call(
args.base_url,
"GET",
"/api/v1/users/me",
headers={"Authorization": "Bearer " + token},
)
instance = headers.get("X-Instance-Id") or headers.get("x-instance-id") or "-"
seen[instance] += 1
print(f" {number:2d}: {status} X-Instance-Id={instance}")
print(f"replicas seen: {len(seen)} {dict(seen)}")
return 0 if len(seen) >= 2 else 1
def compose(*args: str, check: bool = True) -> subprocess.CompletedProcess:
return subprocess.run(
["docker", "compose", *args],
cwd=ROOT,
capture_output=True,
text=True,
check=check,
)
def lb_rows() -> list[dict]:
done = compose("exec", "-T", "haproxy", "bash", "-c", LB_STATS)
lines = [
line for line in done.stdout.splitlines() if line.startswith(("# ", "api,"))
]
header = lines[0][2:].split(",")
rows = []
for line in lines[1:]:
# zip(strict=) — только с Python 3.10, скрипт работает и на 3.9
row = dict(zip(header, line.split(","))) # noqa: B905
if row["svname"] in ("BACKEND", "FRONTEND") or not row.get("addr"):
continue
rows.append(row)
return rows
def lb_stats(_args: argparse.Namespace) -> int:
print("slot " + " ".join(f"{field:>12}" for field in STAT_FIELDS))
for row in lb_rows():
print(
f"{row['svname']:<9} "
+ " ".join(f"{row.get(f, ''):>12}" for f in STAT_FIELDS)
)
return 0
def wait_lb_up(replicas: int, timeout: float = 30) -> bool:
"""Все реплики UP в LB: `--wait` compose ждёт только healthcheck
контейнера, а слот вернувшейся реплики включается после проверок LB."""
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
up = [row for row in lb_rows() if row.get("status") == "UP"]
if len(up) >= replicas:
return True
time.sleep(0.5)
return False
def ps() -> str:
return compose(
"ps", "-a", "--format", "table {{.Name}}\t{{.ID}}\t{{.State}}\t{{.Status}}"
).stdout
def failover_each(args: argparse.Namespace) -> int:
done: set[str] = set()
log = Path(tempfile.mkdtemp(prefix="stop-one-")) / "stop-one.log"
env = {**os.environ, "STOP_ONE_LOG": str(log), "STOP_MODE": args.mode}
attempt = 0
while len(done) < args.replicas and attempt < args.replicas * 4:
attempt += 1
replicas = compose(
"up",
"-d",
"--no-deps",
"--no-recreate",
"--wait",
"--scale",
f"api={args.replicas}",
"api",
check=False,
)
if replicas.returncode != 0 or not wait_lb_up(args.replicas):
print(replicas.stderr or "replicas are not UP in the LB")
return 2
# сдвиг очереди round-robin: тест останавливает реплику, ответившую
# на его первую запись; с каждой попыткой сдвиг на запрос больше
for _ in range(attempt - 1):
call(args.base_url, "GET", "/health/live")
print(f"=== attempt {attempt}: docker compose ps before\n{ps()}", flush=True)
before = log.read_text().splitlines() if log.exists() else []
test = subprocess.run(
[
sys.executable,
"tests/resilience.py",
"--mode",
"failover",
"--action-script",
"scripts/stop-one.sh",
"--base-url",
args.base_url,
],
cwd=ROOT,
env=env,
capture_output=True,
text=True,
check=False,
)
print(
"$ make test-failover ACTION_SCRIPT=scripts/stop-one.sh "
f"(STOP_MODE={args.mode})"
)
print(test.stdout.strip())
lines = log.read_text().splitlines() if log.exists() else []
new = lines[len(before) :]
print("STOP_ONE_LOG: " + (new[-1] if new else "(no line)"))
print(f"docker compose ps after\n{ps()}", flush=True)
if test.returncode != 0:
return test.returncode
stopped = new[-1].split("container=")[1].split()[0][:12] if new else ""
if stopped:
done.add(stopped)
compose(
"up",
"-d",
"--no-deps",
"--no-recreate",
"--wait",
"--scale",
f"api={args.replicas}",
"api",
)
print(f"replicas stopped one by one: {sorted(done)}; all restored:\n{ps()}")
return 0 if len(done) >= args.replicas else 1
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
commands = parser.add_subparsers(dest="command", required=True)
one = commands.add_parser("instances")
one.add_argument("--base-url", default="http://localhost:8080")
one.add_argument("--requests", type=int, default=12)
commands.add_parser("lb-stats")
each = commands.add_parser("failover-each")
each.add_argument("--base-url", default="http://localhost:8080")
each.add_argument("--replicas", type=int, default=2)
each.add_argument("--mode", choices=("stop", "kill"), default="stop")
args = parser.parse_args()
handler = {
"instances": instances,
"lb-stats": lb_stats,
"failover-each": failover_each,
}
return handler[args.command](args)
if __name__ == "__main__":
sys.exit(main())
+20
View File
@@ -0,0 +1,20 @@
#!/bin/sh
set -eu
# Restart hook для make test-persistence (tests/README.md) по образцу
# scripts/restart.example.sh. Перезапускает балансировщик, все реплики API
# и все хранилища стенда — PostgreSQL и Valkey — с сохранением volume,
# схемы и данных: без down -v, FLUSHALL и повторного наполнения. Кэш
# Valkey после рестарта пуст: persistence у него выключен, данные — в
# PostgreSQL.
# LB гасится первым и поднимается последним. start поднимает те же
# контейнеры всех реплик: число реплик не меняется (реплика, которую
# оставил остановленной stop-one.sh, тоже запускается). start api
# запускает и его зависимость migrate: повторный прогон миграций ничего не
# меняет. Готовность через LB ждёт сам тест. Секреты не печатает.
cd "$(dirname "$0")/.."
docker compose stop haproxy api
docker compose restart postgres valkey
# те же контейнеры: --wait только дожидается их healthcheck
docker compose up -d --wait postgres valkey
docker compose start api haproxy
+422
View File
@@ -0,0 +1,422 @@
#!/bin/sh
set -eu
# Поочерёдная замена реплик api на новый образ без простоя (рубрика «4»
# лабы 3): make rolling-update. Правила — infra/AGENTS.md, «Поочерёдная
# замена». Compose сам так не умеет (это update_config Swarm), сторонние
# плагины не используются: ещё одна незакреплённая зависимость.
# 0. предусловия: работает ровно API_REPLICAS реплик, остановленных нет,
# слотов LB с ручным состоянием (drain, maint) нет, все реплики UP в
# LB, для ещё одной есть слот; иначе код 2, ничего не менялось;
# 1. сборка образа из рабочего дерева (ROLLOUT_BUILD=0 — без сборки:
# тег сервиса уже указывает на новый образ, так делает bench/);
# 2. миграции один раз: контейнер сервиса migrate пересоздаётся на новом
# образе и выполняется до новых реплик — в новом образе новые
# ревизии, они только расширяют схему (migrations/AGENTS.md);
# 3–5. для каждой старой реплики: рядом одна новая (--scale N+1
# --no-recreate) → новая healthy и UP в LB → слот старой drain,
# запросов в полёте 0 → maint → docker stop → docker rm → адрес ушёл
# из слота → слот ready.
# Сбой: новая реплика не готова — она удаляется; новая уже UP — вывод
# старой доводится до конца. В любом исходе работает API_REPLICAS реплик,
# слоты LB без ручного состояния; повторный запуск доводит замену.
# Отката нет: откат — вернуть прежний код и снова make rolling-update
# (схема только расширялась, прежний код на ней работает).
# Окружение:
# API_REPLICAS (2) — число реплик до и после;
# ROLLOUT_BUILD (1) — собрать образ сервиса api из рабочего дерева;
# ROLLOUT_MIGRATE (1) — 0: без миграций;
# ROLLOUT_READY_TIMEOUT (60) — срок готовности новой реплики, с;
# ROLLOUT_DRAIN_TIMEOUT (12) — срок дренажа старой, с: больше timeout
# server LB (10 с), дольше запрос через LB не живёт.
# Проект compose — как у самого docker compose: COMPOSE_PROJECT_NAME,
# COMPOSE_FILE, COMPOSE_ENV_FILES или compose.yaml и .env репозитория;
# стенд bench/ (профиль rollout) вызывает этот же скрипт со своими.
# Секретов не печатает. Коды: 0 — замена завершена; 2 — неверный ввод или
# стенд не готов, ничего не менялось; 1 — сбой; 130 / 143 — прерван
# (Ctrl+C / SIGTERM).
cd "$(dirname "$0")/.."
# runtime API HAProxy: только loopback внутри контейнера LB (haproxy.cfg)
LB_API_PORT=9999
replicas="${API_REPLICAS:-2}"
ready_timeout="${ROLLOUT_READY_TIMEOUT:-60}"
drain_timeout="${ROLLOUT_DRAIN_TIMEOUT:-12}"
build="${ROLLOUT_BUILD:-1}"
migrate="${ROLLOUT_MIGRATE:-1}"
# состояние текущей замены для trap: "" — реплики не тронуты, starting —
# новая запущена и ещё не UP, replacing — новая UP, старая выводится из LB
# и удаляется
state=""
before=""
new_id=""
old_id=""
old_addr=""
old_slot=""
step=""
log() {
printf '%s rolling-update: %s\n' "$(date -u +%H:%M:%S)" "$*"
}
fail() {
code=$1
shift
printf '%s rolling-update: error: %s\n' "$(date -u +%H:%M:%S)" "$*" >&2
exit "$code"
}
short() {
printf '%.12s' "$1"
}
count() {
printf '%s\n' "$1" | grep -c . || true
}
# команда runtime API LB изнутри его контейнера (curl и socat в образе
# нет, bash есть); ответ — в stdout
lb() {
docker compose exec -T haproxy bash -c \
'exec 3<>"/dev/tcp/127.0.0.1/$2" && printf "%s\n" "$1" >&3 && cat <&3' \
lb "$1" "$LB_API_PORT"
}
# та же команда LB для оператора — в подсказках ручной уборки
lb_hint() {
printf "docker compose exec -T haproxy bash -c 'exec 3<>/dev/tcp/127.0.0.1/%s && echo \"%s\" >&3 && cat <&3'" \
"$LB_API_PORT" "$1"
}
# смена состояния слота: успешная команда отвечает пустой строкой, ошибка
# — текстом («No such server.»)
lb_set() {
answer=$(lb "set server api/$1 state $2" | tr -d '\r\n')
if [ -n "$answer" ]; then
printf '%s rolling-update: error: LB set server api/%s state %s: %s\n' \
"$(date -u +%H:%M:%S)" "$1" "$2" "$answer" >&2
return 1
fi
}
# занятые слоты backend api: «слот адрес запросов_в_полёте состояние»;
# состояние последним — в нём бывают пробелы («DOWN 1/2»)
slots() {
lb "show stat" | awk -F, '
/^# / { sub(/^# /, ""); for (i = 1; i <= NF; i++) col[$i] = i; next }
$1 == "api" && $2 != "BACKEND" && $(col["addr"]) != "" {
addr = $(col["addr"]); sub(/:[0-9]+$/, "", addr)
print $2, addr, $(col["scur"]), $(col["status"])
}'
}
slot_total() {
lb "show stat" | awk -F, '$1 == "api" && $2 != "BACKEND" && $2 != "" { n++ } END { print n + 0 }'
}
# слоты с ручным состоянием, которое оставила прерванная замена: флаги
# FMAINT (1) и FDRAIN (8) в srv_admin_state; обслуживание по DNS (32) —
# штатное. show stat их не различает: у слота без адреса и то и другое —
# «MAINT (resolution)», а следующей реплике в этом слоте LB запросов не даст
manual_slots() {
lb "show servers state api" | awk '
/^# / { for (i = 2; i <= NF; i++) col[$i] = i - 1; next }
NF > 5 && col["srv_admin_state"] {
s = $(col["srv_admin_state"])
if (s % 2 == 1 || int(s / 8) % 2 == 1) print $(col["srv_name"])
}'
}
# поле слота с адресом $1: 1 — слот, 3 — запросов в полёте, 4 — состояние
slot_field() {
slots | awk -v addr="$1" -v field="$2" '
$2 == addr { if (field == 4) { $1 = $2 = $3 = ""; sub(/^ +/, "") ; print } else print $field; exit }'
}
address() {
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$1"
}
health() {
docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' "$1" 2>/dev/null || echo gone
}
now() {
date +%s
}
# новая реплика — ID, которого не было до up --scale (список before)
find_new() {
for id in $(docker compose ps -a -q --no-trunc api); do
case " $before " in
*" $id "*) ;;
*) printf '%s\n' "$id" ;;
esac
done
}
# дождаться, пока адрес удалённой реплики уйдёт из слота (DNS, hold 1 с),
# не дольше 10 с
wait_address_gone() {
deadline=$(($(now) + 10))
while [ -n "$(slot_field "$1" 1)" ]; do
if [ "$(now)" -ge "$deadline" ]; then
log "$step: address $1 still in slot after 10s"
return 0
fi
sleep 0.25
done
}
# довести вывод старой реплики до удаления (шаги 3–5). Ошибки проверяются
# явно (|| return 1): в trap функция вызывается под if, где set -e не
# действует. Повторный вызов после частичного — тоже корректен: удалённый
# контейнер пропускается
remove_old() {
lb_set "$old_slot" maint || return 1
if docker inspect "$old_id" >/dev/null 2>&1; then
log "$step: maint slot $old_slot, stopping old $(short "$old_id")"
stopping=$(now)
# stop_grace_period сервиса: uvicorn завершается сам за SHUTDOWN_TIMEOUT
docker stop --timeout 10 "$old_id" >/dev/null || return 1
stopped=$(($(now) - stopping))
# код выхода: 0 — graceful по SIGTERM, 137 — SIGKILL по сроку
exited=$(docker inspect -f '{{.State.ExitCode}}' "$old_id" 2>/dev/null || echo '?')
docker rm "$old_id" >/dev/null || return 1
log "$step: removed old $(short "$old_id") (stop ${stopped}s, exit $exited)"
fi
wait_address_gone "$old_addr"
lb_set "$old_slot" ready || return 1
log "$step: slot $old_slot ready"
}
# убрать новую реплику, которая не стала готовой. Есть слот (DNS уже отдал
# его) — maint, затем штатная остановка: стартующий процесс выходит сразу
# по раннему обработчику SIGTERM (src/early_stop.py), работающий —
# дорабатывает запросы, которые LB успел отправить на слот до maint. Слота
# нет — запросов на ней не было, и docker rm -f безопасен: это и страховка
# на первые десятки миллисекунд старта интерпретатора, где SIGTERM ещё
# некому принять. Прерывание между up --scale и поиском новой: ID ещё не
# известен, ищется здесь
remove_new() {
if [ -z "$new_id" ]; then
new_id=$(find_new | tail -n 1)
fi
if [ -z "$new_id" ]; then
log "$step: no new replica was created"
return 0
fi
log "$step: removing new replica $(short "$new_id") that is not ready"
new_addr=$(address "$new_id" 2>/dev/null || true)
new_slot=""
if [ -n "$new_addr" ]; then
new_slot=$(slot_field "$new_addr" 1)
fi
if [ -z "$new_slot" ]; then
docker rm -f "$new_id" >/dev/null || return 1
log "$step: removed new $(short "$new_id") (no slot: docker rm -f)"
return 0
fi
lb_set "$new_slot" maint || return 1
stopping=$(now)
docker stop --timeout 10 "$new_id" >/dev/null || return 1
stopped=$(($(now) - stopping))
exited=$(docker inspect -f '{{.State.ExitCode}}' "$new_id" 2>/dev/null || echo '?')
docker rm -f "$new_id" >/dev/null || return 1
log "$step: removed new $(short "$new_id") (slot $new_slot: stop ${stopped}s, exit $exited)"
wait_address_gone "$new_addr"
lb_set "$new_slot" ready || return 1
}
cleanup() {
code=$?
set +e
trap '' INT TERM
case "$state" in
starting)
if ! remove_new; then
log "manual cleanup: docker rm -f ${new_id:-<new api container>}; slots in manual state: $(lb_hint 'show servers state api') (srv_admin_state 1 or 8); set each ready: $(lb_hint 'set server api/<slot> state ready')"
fi
;;
replacing)
log "$step: new replica is UP, finishing removal of old $(short "$old_id")"
if ! remove_old; then
log "manual cleanup: docker rm -f $old_id; then $(lb_hint "set server api/$old_slot state ready")"
fi
;;
esac
if [ "$code" -ne 0 ] && [ -n "$state" ]; then
log "stopped: $(count "$(docker compose ps -q api)") api replicas running; rerun make rolling-update to finish"
fi
exit "$code"
}
for value in "$replicas" "$ready_timeout" "$drain_timeout"; do
case "$value" in
'' | *[!0-9]* | 0) fail 2 "API_REPLICAS and ROLLOUT_*_TIMEOUT must be positive integers" ;;
esac
done
for value in "$build" "$migrate"; do
case "$value" in
0 | 1) ;;
*) fail 2 "ROLLOUT_BUILD and ROLLOUT_MIGRATE must be 0 or 1" ;;
esac
done
# 0. предусловия — ничего не меняют
if ! lb "show info" >/dev/null 2>&1; then
fail 2 "HAProxy runtime API is unreachable: start the LB with the current infra/haproxy/haproxy.cfg (docker compose up -d --force-recreate --no-deps haproxy)"
fi
old=$(docker compose ps -q --no-trunc api)
all=$(docker compose ps -a -q --no-trunc api)
if [ "$(count "$all")" -ne "$(count "$old")" ]; then
fail 2 "stopped api replicas exist: run make replicas first"
fi
if [ "$(count "$old")" -ne "$replicas" ]; then
fail 2 "$(count "$old") api replicas running, API_REPLICAS=$replicas: run make replicas first"
fi
slots_total=$(slot_total)
if [ $((replicas + 1)) -gt "$slots_total" ]; then
fail 2 "API_REPLICAS + 1 = $((replicas + 1)) replicas do not fit $slots_total LB slots"
fi
# раньше проверки UP: слот работающей реплики в ручном drain — не повод для
# make replicas, а остаток прерванной замены
stuck=$(manual_slots | tr '\n' ' ')
if [ -n "$stuck" ]; then
fail 2 "LB slots left in manual drain/maint by an interrupted rollout: ${stuck% }; set each ready: $(lb_hint 'set server api/<slot> state ready')"
fi
for id in $old; do
status=$(slot_field "$(address "$id")" 4)
if [ "$status" != UP ]; then
fail 2 "replica $(short "$id") is not UP in LB (${status:-no slot}): run make replicas and wait"
fi
done
image=$(docker inspect -f '{{.Config.Image}}' "$(printf '%s\n' "$old" | head -n 1)")
ids=""
for id in $old; do
ids="$ids $(short "$id")"
done
log "start: $replicas replicas${ids}, image $image"
began=$(now)
trap cleanup EXIT
trap 'exit 130' INT
trap 'exit 143' TERM
# 1. сборка: тот же тег сервиса, работающие реплики остаются на прежнем
# образе (контейнер держит образ по ID, а не по тегу)
if [ "$build" = 1 ]; then
started=$(now)
docker compose build api
log "build done in $(($(now) - started))s"
else
log "build skipped (ROLLOUT_BUILD=0): tag $image already points to the new image"
fi
# 2. миграции один раз, до первой новой реплики. Контейнер сервиса migrate
# пересоздаётся на новом образе, а не одноразовый run --rm: иначе в стенде
# остался бы migrate прежнего образа, и restart.sh (start api запускает
# зависимость migrate) гонял бы старые миграции на новой схеме — «Can't
# locate revision», и реплики не стартуют
if [ "$migrate" = 1 ]; then
started=$(now)
if ! docker compose up --no-deps --no-build --force-recreate \
--abort-on-container-exit --exit-code-from migrate migrate; then
fail 1 "migrations failed: no replica was replaced"
fi
log "migrate done in $(($(now) - started))s"
else
log "migrate skipped (ROLLOUT_MIGRATE=0)"
fi
number=0
for old_id in $old; do
number=$((number + 1))
step="replica $number/$replicas"
# 3. одна новая реплика рядом со старыми. new_id прежнего шага — уже
# рабочая реплика: сбросить до state, иначе уборка удалила бы её
new_id=""
before=$(docker compose ps -a -q --no-trunc api | tr '\n' ' ')
state=starting
started=$(now)
docker compose up -d --no-deps --no-recreate --no-build --scale "api=$((replicas + 1))" api
new_id=$(find_new | tail -n 1)
if [ -z "$new_id" ]; then
state=""
fail 1 "$step: compose did not start a new replica"
fi
log "$step: started new $(short "$new_id")"
# 4. новая готова: healthy (или running без healthcheck) и UP в LB по её
# адресу — слот начинает DOWN и включается после rise проверок
deadline=$(($(now) + ready_timeout))
while :; do
current=$(health "$new_id")
status=""
case "$current" in
healthy | running)
new_addr=$(address "$new_id")
if [ -n "$new_addr" ]; then
status=$(slot_field "$new_addr" 4)
fi
if [ "$status" = UP ]; then
break
fi
;;
exited | dead | gone)
fail 1 "$step: new replica $(short "$new_id") $current"
;;
esac
if [ "$(now)" -ge "$deadline" ]; then
fail 1 "$step: new replica $(short "$new_id") not UP in LB within ${ready_timeout}s (container ${current}, LB ${status:-no slot})"
fi
sleep 0.25
done
log "$step: new $(short "$new_id") addr $new_addr slot $(slot_field "$new_addr" 1) UP in $(($(now) - started))s"
# 5. старая: drain → запросов в полёте 0 → maint → stop → rm → ready
old_addr=$(address "$old_id")
old_slot=$(slot_field "$old_addr" 1)
if [ -z "$old_slot" ]; then
fail 1 "$step: old replica $(short "$old_id") has no LB slot"
fi
state=replacing
lb_set "$old_slot" drain
log "$step: drain old $(short "$old_id") addr $old_addr slot $old_slot"
started=$(now)
deadline=$((started + drain_timeout))
while :; do
inflight=$(slot_field "$old_addr" 3)
if [ "${inflight:-0}" = 0 ]; then
log "$step: old $(short "$old_id") idle after $(($(now) - started))s"
break
fi
if [ "$(now)" -ge "$deadline" ]; then
log "$step: drain timeout ${drain_timeout}s, $inflight requests in flight: graceful stop finishes them"
break
fi
sleep 0.25
done
remove_old
state=""
old_slot=""
done
# итог: API_REPLICAS реплик, ни одной прежней, все UP
current=$(docker compose ps -q --no-trunc api)
if [ "$(count "$current")" -ne "$replicas" ]; then
fail 1 "$(count "$current") api replicas running after rollout, expected $replicas"
fi
ids=""
for id in $current; do
case " $(printf '%s\n' "$old" | tr '\n' ' ') " in
*" $id "*) fail 1 "old replica $(short "$id") still running" ;;
esac
status=$(slot_field "$(address "$id")" 4)
if [ "$status" != UP ]; then
fail 1 "replica $(short "$id") is not UP in LB after rollout (${status:-no slot})"
fi
ids="$ids $(short "$id")"
done
log "done: $replicas replicas${ids} UP in $(($(now) - began))s"
+82
View File
@@ -0,0 +1,82 @@
#!/bin/sh
set -eu
# Failover hook для make test-failover (tests/README.md) по образцу
# scripts/stop-one.example.sh; правила — infra/AGENTS.md.
# TARGET_INSTANCE_ID — X-Instance-Id реплики, то есть начало ID её
# контейнера (hostname в compose). Скрипт останавливает ровно одну
# работающую реплику сервиса api этого проекта и оставляет её
# остановленной: restart: unless-stopped не поднимает контейнер ни после
# docker stop, ни после docker kill. PostgreSQL, Valkey, LB, чужие
# контейнеры и volumes не трогает. Восстановление — make replicas.
# STOP_MODE=stop (по умолчанию) — docker stop: SIGTERM и graceful;
# STOP_MODE=kill — docker kill: SIGKILL, отказ процесса без graceful;
# STOP_ONE_LOG=<файл> — дописать строку «время, TARGET_INSTANCE_ID,
# полный ID контейнера, режим»: тест скрывает вывод hook, а evidence
# должно показать, какой контейнер остановлен.
# Секретов и окружения не печатает. Неверный ввод — код 2 до вызова
# docker, нет такой реплики — код 3.
# Проект compose — как у самого docker compose: COMPOSE_PROJECT_NAME,
# COMPOSE_FILE и т. п. или compose.yaml и .env репозитория.
# пустое значение — код 2 в любой оболочке (${VAR:?} даёт 1 в bash и 2 в
# dash)
if [ -z "${TARGET_INSTANCE_ID:-}" ]; then
echo "stop-one: TARGET_INSTANCE_ID is empty; test provides target API instance alias" >&2
exit 2
fi
mode="${STOP_MODE:-stop}"
case "$mode" in
stop | kill) ;;
*)
echo "stop-one: STOP_MODE must be stop or kill" >&2
exit 2
;;
esac
# hostname контейнера — его ID в hex, от 12 символов
case "$TARGET_INSTANCE_ID" in
*[!0-9a-f]*)
echo "stop-one: TARGET_INSTANCE_ID is not a container id" >&2
exit 2
;;
esac
if [ "${#TARGET_INSTANCE_ID}" -lt 12 ] || [ "${#TARGET_INSTANCE_ID}" -gt 64 ]; then
echo "stop-one: TARGET_INSTANCE_ID is not a container id" >&2
exit 2
fi
cd "$(dirname "$0")/.."
# только работающие реплики сервиса api этого проекта, полные ID
match=""
for id in $(docker compose ps -q --no-trunc api); do
case "$id" in
"$TARGET_INSTANCE_ID"*)
if [ -n "$match" ]; then
echo "stop-one: TARGET_INSTANCE_ID matches several replicas" >&2
exit 3
fi
match="$id"
;;
esac
done
if [ -z "$match" ]; then
echo "stop-one: no running api replica of this project matches TARGET_INSTANCE_ID" >&2
exit 3
fi
if [ "$mode" = stop ]; then
# uvicorn завершается сам не позже SHUTDOWN_TIMEOUT (5 с, не больше 9);
# срок 9 с гарантирует возврат hook раньше 10 с и для зависшего процесса
docker stop --timeout 9 "$match" >/dev/null
else
docker kill "$match" >/dev/null
fi
if [ -n "${STOP_ONE_LOG:-}" ]; then
printf '%s TARGET_INSTANCE_ID=%s container=%s mode=%s\n' \
"$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$TARGET_INSTANCE_ID" "$match" "$mode" \
>>"$STOP_ONE_LOG"
fi
echo "stop-one: stopped api container $(printf '%.12s' "$match") (mode $mode)" >&2