feat: add replicated messenger and reproducible lab3 stand
This commit is contained in:
Executable
+251
@@ -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())
|
||||
Executable
+20
@@ -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
|
||||
Executable
+422
@@ -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"
|
||||
Executable
+82
@@ -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
|
||||
Reference in New Issue
Block a user