feat: implement lab 5 queued image processing
This commit is contained in:
Executable
+818
@@ -0,0 +1,818 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Операторские команды стенда лабы 5 (свои, не skeleton). Python 3.9+, stdlib.
|
||||
|
||||
python3 scripts/lab5.py env
|
||||
.env из .env.example со случайными паролями и ключами S3 (make env);
|
||||
несекретные переменные, заданные в окружении (`make env
|
||||
HOST_PORT=8180`), берутся оттуда — так стенд встаёт рядом с чужим
|
||||
на других портах. Существующий .env не перезаписывается,
|
||||
дописываются только переменные шаблона, которых в нём нет.
|
||||
Печатает только имена;
|
||||
python3 scripts/lab5.py instances [--base-url URL] [--requests 12]
|
||||
вход одним синтетическим пользователем и серия GET /users/me с одним
|
||||
токеном через LB: X-Instance-Id каждого ответа и итог по репликам
|
||||
(шаг 1 сценария защиты лабы 3);
|
||||
python3 scripts/lab5.py lb-stats
|
||||
слоты HAProxy рабочего стенда: адрес, состояние проверки, запросы в
|
||||
полёте, всего, ошибки соединения, повторы, перенаправления;
|
||||
python3 scripts/lab5.py failover-each [--base-url URL] [--replicas 2]
|
||||
[--mode stop|kill]
|
||||
make test-failover для каждой реплики по очереди: перед прогоном все
|
||||
реплики возвращены (make replicas), тест останавливает реплику,
|
||||
ответившую на его первую запись; если это реплика, которую уже
|
||||
проверили, очередь LB сдвигается одним запросом и прогон
|
||||
повторяется. Печатает docker compose ps до и после, строку
|
||||
STOP_ONE_LOG и итог теста — это evidence «какой контейнер
|
||||
действительно остановлен»;
|
||||
python3 scripts/lab5.py attachment-failover [--base-url URL]
|
||||
[--replicas 2] [--mode stop|kill]
|
||||
загрузка tests/fixtures/sample.png через LB (202, затем ready),
|
||||
сообщение со ссылкой, остановка именно реплики, принявшей загрузку
|
||||
(scripts/stop-one.sh по X-Instance-Id ответа), скачивание вторым
|
||||
участником через другую реплику — тот же SHA-256, 404 постороннему;
|
||||
затем реплики возвращаются;
|
||||
python3 scripts/lab5.py defense [--base-url URL]
|
||||
сценарий защиты лабы 5, шаги 2–3: worker остановлен → загрузка 202 →
|
||||
сообщение со ссылкой 201 → content 409, текст 201 → scripts/restart.sh
|
||||
(LB, реплики, PostgreSQL, Valkey, S3, брокер) → worker запущен → ready,
|
||||
оригинал и thumbnail 256×160. Печатает id и StartedAt без токенов;
|
||||
python3 scripts/lab5.py pipeline
|
||||
задания по состояниям, возраст старейшего, сообщения в очереди;
|
||||
python3 scripts/lab5.py s3-check
|
||||
приватность bucket вне API (make s3-check): bootstrap в режиме
|
||||
check (права ключей API, worker и уборщика, чужой bucket,
|
||||
административные запросы), анонимные запросы с хоста и из сети
|
||||
стенда, порты контейнера S3 из сети, затем cleanup. Таблица «где →
|
||||
проверка → ожидаемо → получено», код 1 при нарушении.
|
||||
|
||||
Пароли синтетических пользователей и токены живут только в памяти и не
|
||||
печатаются. Работает с проектом compose репозитория (compose.yaml и .env)
|
||||
или с тем, что задают COMPOSE_PROJECT_NAME / COMPOSE_FILE /
|
||||
COMPOSE_ENV_FILES (стенды student-tests/stand.py).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from collections import Counter
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
FIXTURE = ROOT / "tests" / "fixtures" / "sample.png"
|
||||
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")
|
||||
# пустые значения этих переменных шаблона — секреты: make env их генерирует
|
||||
SECRET_SUFFIXES = ("_PASSWORD", "_KEY")
|
||||
# порты API S3 и gRPC шлюза: единственные, что открыты в сеть стенда
|
||||
S3_NETWORK_PORTS = ("8333", "18333")
|
||||
|
||||
|
||||
def call(base: str, method: str, path: str, headers=None, body=None, raw=None):
|
||||
data = json.dumps(body).encode() if body is not None else raw
|
||||
request = urllib.request.Request(base + path, data=data, method=method)
|
||||
for key, value in (headers or {}).items():
|
||||
request.add_header(key, value)
|
||||
if body 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 register(base: str, label: str = "ops") -> dict:
|
||||
"""Синтетический пользователь с паролем и входом: id и токен."""
|
||||
username = f"{label}_" + secrets.token_hex(6)
|
||||
password = secrets.token_urlsafe(18)
|
||||
status, _, data = call(
|
||||
base,
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
body={"username": username, "display_name": "Оператор", "password": password},
|
||||
)
|
||||
if status != 201:
|
||||
raise SystemExit(f"register -> {status}")
|
||||
user_id = json.loads(data)["id"]
|
||||
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 {"id": user_id, "token": json.loads(data)["token"]}
|
||||
|
||||
|
||||
def login(base: str) -> str:
|
||||
return register(base)["token"]
|
||||
|
||||
|
||||
def bearer(actor: dict) -> dict:
|
||||
return {"Authorization": "Bearer " + actor["token"]}
|
||||
|
||||
|
||||
def instance_of(headers: dict) -> str:
|
||||
return headers.get("X-Instance-Id") or headers.get("x-instance-id") or "-"
|
||||
|
||||
|
||||
# --- env ------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _assignments(text: str) -> list[tuple[str, str]]:
|
||||
pairs = []
|
||||
for line in text.splitlines():
|
||||
match = re.match(r"([A-Z][A-Z0-9_]*)=(.*)$", line)
|
||||
if match:
|
||||
pairs.append((match.group(1), match.group(2)))
|
||||
return pairs
|
||||
|
||||
|
||||
def _value(name: str, value: str) -> str:
|
||||
"""Значение для нового .env: секрет — случайный, несекретная переменная
|
||||
из окружения (`make env HOST_PORT=8180`) — как задано, иначе шаблон."""
|
||||
if name.endswith(SECRET_SUFFIXES):
|
||||
# ключи S3 и пароли — случайный hex; длина ключа S3 — 64 символа
|
||||
return value or secrets.token_hex(32 if name.startswith("S3_") else 16)
|
||||
return os.environ.get(name, value)
|
||||
|
||||
|
||||
def env(_args: argparse.Namespace) -> int:
|
||||
template = (ROOT / ".env.example").read_text(encoding="utf-8")
|
||||
target = ROOT / ".env"
|
||||
if not target.exists():
|
||||
lines = []
|
||||
generated = []
|
||||
for line in template.splitlines():
|
||||
match = re.match(r"([A-Z][A-Z0-9_]*)=(.*)$", line)
|
||||
if match:
|
||||
value = _value(match.group(1), match.group(2))
|
||||
if value != match.group(2) and match.group(1).endswith(SECRET_SUFFIXES):
|
||||
generated.append(match.group(1))
|
||||
line = f"{match.group(1)}={value}"
|
||||
lines.append(line)
|
||||
target.write_text("\n".join(lines) + "\n", encoding="utf-8")
|
||||
target.chmod(0o600)
|
||||
print(f".env created; generated: {' '.join(generated) or '-'}")
|
||||
return 0
|
||||
existing = {name for name, _ in _assignments(target.read_text(encoding="utf-8"))}
|
||||
missing = [(n, v) for n, v in _assignments(template) if n not in existing]
|
||||
if missing:
|
||||
with target.open("a", encoding="utf-8") as handle:
|
||||
handle.write("\n# added by make env from .env.example\n")
|
||||
for name, value in missing:
|
||||
handle.write(f"{name}={_value(name, value)}\n")
|
||||
print("added to existing .env: " + " ".join(name for name, _ in missing))
|
||||
else:
|
||||
print(".env ready")
|
||||
return 0
|
||||
|
||||
|
||||
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 wait_status(
|
||||
base: str, actor: dict, attachment_id: str, wanted: tuple, timeout: float = 60
|
||||
) -> dict:
|
||||
"""Опрос метаданных, пока статус не войдёт в `wanted`."""
|
||||
deadline = time.monotonic() + timeout
|
||||
while True:
|
||||
status, _, data = call(
|
||||
base, "GET", f"/api/v1/attachments/{attachment_id}", headers=bearer(actor)
|
||||
)
|
||||
if status == 200:
|
||||
meta = json.loads(data)
|
||||
if meta["status"] in wanted:
|
||||
return meta
|
||||
if time.monotonic() > deadline:
|
||||
raise SystemExit(f"attachment did not reach {wanted} in {timeout:.0f} s")
|
||||
time.sleep(0.3)
|
||||
|
||||
|
||||
def restore_replicas(replicas: int) -> None:
|
||||
compose(
|
||||
"up",
|
||||
"-d",
|
||||
"--no-deps",
|
||||
"--no-recreate",
|
||||
"--wait",
|
||||
"--scale",
|
||||
f"api={replicas}",
|
||||
"api",
|
||||
)
|
||||
wait_lb_up(replicas)
|
||||
|
||||
|
||||
def attachment_failover(args: argparse.Namespace) -> int:
|
||||
base = args.base_url
|
||||
restore_replicas(args.replicas)
|
||||
alice, bob, eve = (register(base, label) for label in ("alice", "bob", "eve"))
|
||||
status, _, data = call(
|
||||
base,
|
||||
"POST",
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
body={"title": "Отказ реплики", "member_ids": [alice["id"], bob["id"]]},
|
||||
)
|
||||
if status != 201:
|
||||
raise SystemExit(f"create chat -> {status}")
|
||||
chat = json.loads(data)["id"]
|
||||
content = FIXTURE.read_bytes()
|
||||
expected = hashlib.sha256(content).hexdigest()
|
||||
status, headers, data = call(
|
||||
base,
|
||||
"POST",
|
||||
f"/api/v1/chats/{chat}/attachments?filename=sample.png",
|
||||
headers={**bearer(alice), "Content-Type": "image/png"},
|
||||
raw=content,
|
||||
)
|
||||
if status != 202:
|
||||
raise SystemExit(f"upload -> {status} {data[:200]!r}")
|
||||
attachment = json.loads(data)
|
||||
uploader = instance_of(headers)
|
||||
print(
|
||||
f"upload: 202 {attachment['status']} X-Instance-Id={uploader} "
|
||||
f"size={attachment['size_bytes']} sha256={attachment['sha256'][:16]}… "
|
||||
f"(fixture {expected[:16]}…)"
|
||||
)
|
||||
ready = wait_status(base, alice, attachment["id"], ("ready", "failed"))
|
||||
print(f"processed: {ready['status']} variants={len(ready['variants'])}")
|
||||
status, headers, data = call(
|
||||
base,
|
||||
"POST",
|
||||
f"/api/v1/chats/{chat}/messages",
|
||||
headers={**bearer(alice), "Idempotency-Key": uuid.uuid4().hex},
|
||||
body={"text": "", "attachment_ids": [attachment["id"]]},
|
||||
)
|
||||
print(
|
||||
f"message with attachment: {status} attachment_ids="
|
||||
f"{json.loads(data).get('attachment_ids') if status == 201 else '-'}"
|
||||
)
|
||||
log = Path(tempfile.mkdtemp(prefix="stop-one-")) / "stop-one.log"
|
||||
print(f"=== docker compose ps before\n{ps()}", flush=True)
|
||||
stop = subprocess.run(
|
||||
["scripts/stop-one.sh"],
|
||||
cwd=ROOT,
|
||||
env={
|
||||
**os.environ,
|
||||
"TARGET_INSTANCE_ID": uploader,
|
||||
"STOP_MODE": args.mode,
|
||||
"STOP_ONE_LOG": str(log),
|
||||
},
|
||||
capture_output=True,
|
||||
text=True,
|
||||
check=False,
|
||||
)
|
||||
print(f"$ TARGET_INSTANCE_ID={uploader} STOP_MODE={args.mode} scripts/stop-one.sh")
|
||||
stopped = log.read_text().strip() if log.exists() else "-"
|
||||
print(f"exit {stop.returncode}; STOP_ONE_LOG: {stopped}")
|
||||
if stop.returncode != 0:
|
||||
print(stop.stderr.strip())
|
||||
return 1
|
||||
# LB исключает реплику за ≤ 2,5 с; ответы ещё могут прийти от неё —
|
||||
# ждём ответа другой реплики не дольше 10 с
|
||||
deadline = time.monotonic() + 10
|
||||
started = time.monotonic()
|
||||
result = None
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
status, headers, data = call(
|
||||
base,
|
||||
"GET",
|
||||
f"/api/v1/attachments/{attachment['id']}/content",
|
||||
headers=bearer(bob),
|
||||
)
|
||||
except OSError:
|
||||
status, headers, data = 0, {}, b""
|
||||
if status == 200 and instance_of(headers) != uploader:
|
||||
result = (status, headers, data)
|
||||
break
|
||||
time.sleep(0.2)
|
||||
ok = result is not None
|
||||
if result is not None:
|
||||
status, headers, data = result
|
||||
digest = hashlib.sha256(data).hexdigest()
|
||||
ok = digest == expected and instance_of(headers) != uploader
|
||||
kind = headers.get("content-type") or headers.get("Content-Type")
|
||||
print(
|
||||
f"download by bob after stop: {status} "
|
||||
f"X-Instance-Id={instance_of(headers)} "
|
||||
f"after {time.monotonic() - started:.2f}s, bytes={len(data)}, "
|
||||
f"sha256 {'== fixture' if digest == expected else '!= fixture'}, "
|
||||
f"content-type={kind}"
|
||||
)
|
||||
else:
|
||||
print("download by bob after stop: no 200 from another replica in 10 s")
|
||||
for suffix in ("", "/content"):
|
||||
status, _, _ = call(
|
||||
base,
|
||||
"GET",
|
||||
f"/api/v1/attachments/{attachment['id']}{suffix}",
|
||||
headers=bearer(eve),
|
||||
)
|
||||
print(f"outsider GET /attachments/{{id}}{suffix}: {status}")
|
||||
ok = ok and status == 404
|
||||
print(f"=== docker compose ps after\n{ps()}", flush=True)
|
||||
restore_replicas(args.replicas)
|
||||
print(f"replicas restored:\n{ps()}")
|
||||
print("PASS" if ok else "FAIL")
|
||||
return 0 if ok else 1
|
||||
|
||||
|
||||
# --- лаба 5: сценарий защиты и состояние pipeline ------------------------------
|
||||
|
||||
|
||||
def started_at(service: str) -> str:
|
||||
ids = compose("ps", "-q", service, check=False).stdout.split()
|
||||
if not ids:
|
||||
return f"{service}: not running"
|
||||
done = subprocess.run(
|
||||
["docker", "inspect", "-f", "{{.Name}} {{.State.StartedAt}}", *ids],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
check=False,
|
||||
)
|
||||
return "; ".join(line.strip().lstrip("/") for line in done.stdout.splitlines())
|
||||
|
||||
|
||||
def jpeg_size(data: bytes) -> tuple:
|
||||
"""Размеры JPEG по маркеру SOF (как tests/image_probe.py)."""
|
||||
i = 2
|
||||
while i + 9 < len(data):
|
||||
if data[i] != 0xFF:
|
||||
i += 1
|
||||
continue
|
||||
marker = data[i + 1]
|
||||
length = int.from_bytes(data[i + 2 : i + 4], "big")
|
||||
if marker in (0xC0, 0xC1, 0xC2):
|
||||
height = int.from_bytes(data[i + 5 : i + 7], "big")
|
||||
width = int.from_bytes(data[i + 7 : i + 9], "big")
|
||||
return width, height
|
||||
i += 2 + length
|
||||
return (0, 0)
|
||||
|
||||
|
||||
def defense(args: argparse.Namespace) -> int:
|
||||
base = args.base_url
|
||||
services = ("api", "postgres", "valkey", "s3", "rabbitmq", "worker", "relay")
|
||||
print("$ docker compose stop worker")
|
||||
compose("stop", "worker")
|
||||
ok = True
|
||||
try:
|
||||
alice, bob = (register(base, label) for label in ("alice", "bob"))
|
||||
status, _, data = call(
|
||||
base,
|
||||
"POST",
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
body={"title": "Защита", "member_ids": [alice["id"], bob["id"]]},
|
||||
)
|
||||
chat = json.loads(data)["id"]
|
||||
content = FIXTURE.read_bytes()
|
||||
status, _, data = call(
|
||||
base,
|
||||
"POST",
|
||||
f"/api/v1/chats/{chat}/attachments?filename=sample.png",
|
||||
headers={**bearer(alice), "Content-Type": "image/png"},
|
||||
raw=content,
|
||||
)
|
||||
attachment = json.loads(data)
|
||||
print(f"worker stopped; upload -> {status} {attachment.get('status')}")
|
||||
print(f"attachment_id={attachment.get('id')}")
|
||||
ok = ok and status == 202
|
||||
status, _, data = call(
|
||||
base,
|
||||
"POST",
|
||||
f"/api/v1/chats/{chat}/messages",
|
||||
headers={**bearer(alice), "Idempotency-Key": uuid.uuid4().hex},
|
||||
body={"text": "", "attachment_ids": [attachment["id"]]},
|
||||
)
|
||||
print(f"message with queued attachment -> {status}")
|
||||
ok = ok and status == 201
|
||||
status, _, _ = call(
|
||||
base,
|
||||
"GET",
|
||||
f"/api/v1/attachments/{attachment['id']}/content",
|
||||
headers=bearer(bob),
|
||||
)
|
||||
print(f"content while worker is stopped -> {status}")
|
||||
ok = ok and status == 409
|
||||
status, _, _ = call(
|
||||
base,
|
||||
"POST",
|
||||
f"/api/v1/chats/{chat}/messages",
|
||||
headers={**bearer(bob), "Idempotency-Key": uuid.uuid4().hex},
|
||||
body={"text": "текст без вложения"},
|
||||
)
|
||||
print(f"plain text message meanwhile -> {status}")
|
||||
ok = ok and status == 201
|
||||
print("StartedAt before restart:")
|
||||
for service in services:
|
||||
print(" " + started_at(service))
|
||||
restart = subprocess.run(
|
||||
["scripts/restart.sh"],
|
||||
cwd=ROOT,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
check=False,
|
||||
)
|
||||
print(f"$ scripts/restart.sh -> exit {restart.returncode}")
|
||||
ok = ok and restart.returncode == 0
|
||||
deadline = time.monotonic() + 90
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
if call(base, "GET", "/health/ready")[0] == 200:
|
||||
break
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(0.5)
|
||||
meta = wait_status(base, bob, attachment["id"], ("queued", "processing"), 30)
|
||||
print(f"after restart, worker still stopped: {meta['status']}")
|
||||
finally:
|
||||
print("$ docker compose start worker")
|
||||
compose("up", "-d", "--no-deps", "worker")
|
||||
meta = wait_status(base, bob, attachment["id"], ("ready", "failed"))
|
||||
print(f"after worker start: {meta['status']} error_code={meta['error_code']}")
|
||||
ok = ok and meta["status"] == "ready"
|
||||
status, _, data = call(
|
||||
base,
|
||||
"GET",
|
||||
f"/api/v1/attachments/{attachment['id']}/content",
|
||||
headers=bearer(bob),
|
||||
)
|
||||
same = hashlib.sha256(data).hexdigest() == hashlib.sha256(content).hexdigest()
|
||||
print(f"original -> {status}, sha256 {'== fixture' if same else '!= fixture'}")
|
||||
ok = ok and status == 200 and same
|
||||
status, _, data = call(
|
||||
base,
|
||||
"GET",
|
||||
f"/api/v1/attachments/{attachment['id']}/content?variant=thumbnail",
|
||||
headers=bearer(bob),
|
||||
)
|
||||
print(f"thumbnail -> {status}, JPEG {jpeg_size(data)}")
|
||||
ok = ok and status == 200 and jpeg_size(data) == (256, 160)
|
||||
print("StartedAt after:")
|
||||
for service in services:
|
||||
print(" " + started_at(service))
|
||||
print("PASS" if ok else "FAIL")
|
||||
return 0 if ok else 1
|
||||
|
||||
|
||||
PIPELINE_SQL = (
|
||||
"SELECT state, count(*), "
|
||||
"coalesce(round(extract(epoch FROM now() - min(created_at))::numeric, 1), 0) "
|
||||
"FROM attachment_jobs GROUP BY state ORDER BY state"
|
||||
)
|
||||
|
||||
|
||||
def pipeline(_args: argparse.Namespace) -> int:
|
||||
db = _env_value("POSTGRES_DB", "messenger")
|
||||
user = _env_value("POSTGRES_USER", "messenger")
|
||||
done = compose(
|
||||
"exec",
|
||||
"-T",
|
||||
"postgres",
|
||||
"psql",
|
||||
"-U",
|
||||
user,
|
||||
"-d",
|
||||
db,
|
||||
"-At",
|
||||
"-F",
|
||||
" ",
|
||||
"-c",
|
||||
PIPELINE_SQL,
|
||||
check=False,
|
||||
)
|
||||
print("state count oldest_s")
|
||||
print(done.stdout.strip() or done.stderr.strip())
|
||||
queues = compose(
|
||||
"exec",
|
||||
"-T",
|
||||
"rabbitmq",
|
||||
"rabbitmqctl",
|
||||
"-q",
|
||||
"list_queues",
|
||||
"name",
|
||||
"messages_ready",
|
||||
"messages_unacknowledged",
|
||||
"consumers",
|
||||
check=False,
|
||||
)
|
||||
print("queue ready unacked consumers")
|
||||
print(queues.stdout.strip() or queues.stderr.strip())
|
||||
return done.returncode
|
||||
|
||||
|
||||
# --- приватность bucket вне API ------------------------------------------------
|
||||
|
||||
|
||||
def _env_value(name: str, default: str) -> str:
|
||||
env_file = os.environ.get("COMPOSE_ENV_FILES") or str(ROOT / ".env")
|
||||
path = Path(env_file.split(",")[0])
|
||||
if path.exists():
|
||||
for key, value in _assignments(path.read_text(encoding="utf-8")):
|
||||
if key == name and value:
|
||||
return value
|
||||
return os.environ.get(name) or default
|
||||
|
||||
|
||||
def _http_status(url: str, method: str = "GET", data: bytes | None = None) -> str:
|
||||
request = urllib.request.Request(url, data=data, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=5) as response:
|
||||
return str(response.status)
|
||||
except urllib.error.HTTPError as error:
|
||||
return str(error.code)
|
||||
except OSError as error:
|
||||
return type(error).__name__
|
||||
|
||||
|
||||
def _network_status(path: str, method: str = "GET") -> str:
|
||||
"""Анонимный запрос к API S3 из сети стенда (контейнер LB, bash /dev/tcp)."""
|
||||
request = (
|
||||
f"{method} {path} HTTP/1.0\\r\\nHost: s3\\r\\nContent-Length: 0\\r\\n\\r\\n"
|
||||
)
|
||||
script = f"exec 3<>/dev/tcp/s3/8333 && printf '{request}' >&3 && head -n 1 <&3"
|
||||
done = compose("exec", "-T", "haproxy", "bash", "-c", script, check=False)
|
||||
match = re.search(r"HTTP/1\.[01] (\d{3})", done.stdout)
|
||||
return match.group(1) if match else "no answer"
|
||||
|
||||
|
||||
def _port_open(port: str) -> bool:
|
||||
script = f"timeout 2 bash -c 'exec 3<>/dev/tcp/s3/{port}'"
|
||||
return (
|
||||
compose("exec", "-T", "haproxy", "bash", "-c", script, check=False).returncode
|
||||
== 0
|
||||
)
|
||||
|
||||
|
||||
def s3_check(_args: argparse.Namespace) -> int:
|
||||
rows: list[tuple[str, str, str, str]] = []
|
||||
print("$ docker compose run --rm --no-deps s3-bootstrap check")
|
||||
check = compose("run", "--rm", "--no-deps", "s3-bootstrap", "check", check=False)
|
||||
for line in check.stdout.splitlines():
|
||||
parts = line.split("\t")
|
||||
if line.startswith("s3-bootstrap: check") and len(parts) == 5:
|
||||
rows.append(("bootstrap (loopback s3)", parts[1], parts[2], parts[3]))
|
||||
elif line.strip():
|
||||
print(line)
|
||||
if check.returncode != 0:
|
||||
print(check.stderr.strip())
|
||||
bucket = _env_value("S3_BUCKET", "messenger-attachments")
|
||||
host = f"http://127.0.0.1:{_env_value('S3_HOST_PORT', '8334')}"
|
||||
probe = f"/{bucket}/.s3-check/probe"
|
||||
try:
|
||||
for name, url, method in (
|
||||
("anonymous get object", host + probe, "GET"),
|
||||
("anonymous head object", host + probe, "HEAD"),
|
||||
("anonymous list objects", f"{host}/{bucket}?list-type=2", "GET"),
|
||||
("anonymous list buckets", host + "/", "GET"),
|
||||
):
|
||||
rows.append(("host 127.0.0.1", name, "403", _http_status(url, method)))
|
||||
rows.append(
|
||||
(
|
||||
"host 127.0.0.1",
|
||||
"anonymous put object",
|
||||
"403",
|
||||
_http_status(f"{host}/{bucket}/.s3-check/anonymous", "PUT", b"x"),
|
||||
)
|
||||
)
|
||||
for name, path, method in (
|
||||
("anonymous get object", probe, "GET"),
|
||||
("anonymous list objects", f"/{bucket}?list-type=2", "GET"),
|
||||
("anonymous put object", f"/{bucket}/.s3-check/anonymous", "PUT"),
|
||||
):
|
||||
rows.append(
|
||||
("stand network (haproxy)", name, "403", _network_status(path, method))
|
||||
)
|
||||
listening = compose(
|
||||
"exec", "-T", "s3", "sh", "-c", "netstat -tln", check=False
|
||||
).stdout
|
||||
ports = sorted(
|
||||
{
|
||||
m.group(1)
|
||||
for m in re.finditer(r"\s\S+:(\d+)\s+\S+:\*?\S*\s+LISTEN", listening)
|
||||
},
|
||||
key=int,
|
||||
)
|
||||
for port in ports:
|
||||
expected = "open" if port in S3_NETWORK_PORTS else "closed"
|
||||
got = "open" if _port_open(port) else "closed"
|
||||
rows.append(("stand network (haproxy)", f"s3 port {port}", expected, got))
|
||||
finally:
|
||||
cleanup = compose(
|
||||
"run", "--rm", "--no-deps", "s3-bootstrap", "cleanup", check=False
|
||||
)
|
||||
print(
|
||||
"$ docker compose run --rm --no-deps s3-bootstrap cleanup -> exit",
|
||||
cleanup.returncode,
|
||||
)
|
||||
failed = 0
|
||||
print(f"{'where':<26} {'check':<46} {'expected':>8} {'got':>8} verdict")
|
||||
for where, name, expected, got in rows:
|
||||
verdict = "ok" if expected == got else "FAIL"
|
||||
failed += verdict != "ok"
|
||||
print(f"{where:<26} {name:<46} {expected:>8} {got:>8} {verdict}")
|
||||
print(f"checks: {len(rows)}, failed: {failed}, bootstrap exit {check.returncode}")
|
||||
return 1 if failed or check.returncode != 0 else 0
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
commands = parser.add_subparsers(dest="command", required=True)
|
||||
commands.add_parser("env")
|
||||
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")
|
||||
attachment = commands.add_parser("attachment-failover")
|
||||
attachment.add_argument("--base-url", default="http://localhost:8080")
|
||||
attachment.add_argument("--replicas", type=int, default=2)
|
||||
attachment.add_argument("--mode", choices=("stop", "kill"), default="stop")
|
||||
commands.add_parser("s3-check")
|
||||
scenario = commands.add_parser("defense")
|
||||
scenario.add_argument("--base-url", default="http://localhost:8080")
|
||||
commands.add_parser("pipeline")
|
||||
args = parser.parse_args()
|
||||
handler = {
|
||||
"env": env,
|
||||
"instances": instances,
|
||||
"lb-stats": lb_stats,
|
||||
"failover-each": failover_each,
|
||||
"attachment-failover": attachment_failover,
|
||||
"s3-check": s3_check,
|
||||
"defense": defense,
|
||||
"pipeline": pipeline,
|
||||
}
|
||||
return handler[args.command](args)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
Executable
+20
@@ -0,0 +1,20 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# make test-persistence ACTION_SCRIPT=scripts/restart.sh (по образцу
|
||||
# restart.example.sh). Перезапуск с сохранением volume: LB и все реплики
|
||||
# API, PostgreSQL, Valkey, S3 и RabbitMQ (сообщения quorum-очереди — на
|
||||
# его диске). Ничего не удаляется и не наполняется заново; кэш Valkey
|
||||
# пуст и так, он без persistence.
|
||||
#
|
||||
# Relay, worker и cleaner не трогаются: это не хранилища, отказ брокера и
|
||||
# БД они переживают сами, переподключаясь. Если worker остановлен (шаг
|
||||
# сценария защиты), он и останется остановленным.
|
||||
#
|
||||
# start тех же контейнеров: число реплик прежнее, migrate и s3-bootstrap
|
||||
# прогоняются повторно и ничего не меняют. Готовность ждёт сам тест.
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
docker compose stop haproxy api
|
||||
docker compose restart postgres valkey s3 rabbitmq
|
||||
docker compose up -d --wait --no-recreate postgres valkey s3 rabbitmq
|
||||
docker compose start api haproxy
|
||||
Executable
+428
@@ -0,0 +1,428 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# make rolling-update: реплики api по одной переводятся на свежий образ,
|
||||
# а API всё это время отвечает (рубрика «4» лабы 3, требование осталось и
|
||||
# дальше). Подробности — infra/AGENTS.md, «Поочерёдная замена». В compose
|
||||
# такого режима нет (update_config бывает только у Swarm), а сторонний
|
||||
# плагин ради этого означал бы ещё одну незакреплённую зависимость.
|
||||
#
|
||||
# Шаги:
|
||||
# 0. проверка стенда. Живых реплик ровно API_REPLICAS, остановленных
|
||||
# нет, каждая UP в LB; слотов, брошенных в drain/maint, нет; под ещё
|
||||
# одну реплику есть свободный слот. Иначе выход с кодом 2 до любых
|
||||
# изменений;
|
||||
# 1. сборка образа из рабочего дерева. ROLLOUT_BUILD=0 пропускает шаг —
|
||||
# так работает bench/, который заранее вешает тег на нужный образ;
|
||||
# 2. migrate на новом образе, один раз и до первой новой реплики. Ревизии
|
||||
# только добавляют схему (migrations/AGENTS.md), и старые реплики
|
||||
# на ней продолжают работать;
|
||||
# 3–5. цикл по старым репликам: up --scale N+1 --no-recreate добавляет
|
||||
# одну новую; ждём её healthy и UP в LB; слот старой уходит в drain,
|
||||
# пока активных запросов не станет 0, затем в maint; docker stop и rm;
|
||||
# когда DNS уберёт адрес, слот снова ready.
|
||||
# Если что-то сорвалось: не готовую новую реплику удаляем, а если новая
|
||||
# уже UP — старую всё равно выводим до конца. При любом исходе живых
|
||||
# реплик остаётся API_REPLICAS, ручных состояний в LB нет, и повторный
|
||||
# запуск продолжит работу. Отдельного отката нет: вернуть прежний код и
|
||||
# запустить ещё раз (схема только расширялась, старый код на ней живёт).
|
||||
#
|
||||
# Переменные:
|
||||
# API_REPLICAS (2) — сколько реплик должно быть в начале и в конце;
|
||||
# ROLLOUT_BUILD (1) — собирать ли образ api из рабочего дерева;
|
||||
# ROLLOUT_MIGRATE (1) — запускать ли миграции;
|
||||
# ROLLOUT_READY_TIMEOUT (60) — секунд на то, чтобы новая стала UP;
|
||||
# ROLLOUT_DRAIN_TIMEOUT (90) — секунд на дренаж старой. Запас над самой
|
||||
# длинной загрузкой вложения (~81 с, set-timeout в haproxy.cfg), чтобы
|
||||
# плановая замена её не рвала; обычно дренаж занимает доли секунды.
|
||||
# Проект compose выбирают те же переменные, что и для docker compose
|
||||
# (COMPOSE_PROJECT_NAME, COMPOSE_FILE, COMPOSE_ENV_FILES), по умолчанию —
|
||||
# compose.yaml и .env из корня; поэтому профиль rollout в bench/ зовёт
|
||||
# этот же скрипт. Секреты в вывод не попадают.
|
||||
# Выход: 0 — все реплики заменены; 2 — плохие параметры или стенд не в
|
||||
# том состоянии (ничего не тронуто); 1 — ошибка по ходу; 130 и 143 —
|
||||
# прерывание через Ctrl+C и SIGTERM.
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
# порт runtime API из haproxy.cfg; слушает он только 127.0.0.1 контейнера LB
|
||||
LB_API_PORT=9999
|
||||
|
||||
replicas="${API_REPLICAS:-2}"
|
||||
ready_timeout="${ROLLOUT_READY_TIMEOUT:-60}"
|
||||
drain_timeout="${ROLLOUT_DRAIN_TIMEOUT:-90}"
|
||||
build="${ROLLOUT_BUILD:-1}"
|
||||
migrate="${ROLLOUT_MIGRATE:-1}"
|
||||
|
||||
# фаза текущего круга — по ней trap решает, что прибирать. Пусто: ничего
|
||||
# не трогали. starting: контейнер новой реплики есть, в LB он пока не 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 через exec в контейнер LB. В образе нет
|
||||
# ни curl, ни socat, поэтому используется /dev/tcp из bash
|
||||
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_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"
|
||||
}
|
||||
|
||||
# set server ... state: при успехе HAProxy ничего не пишет, при ошибке
|
||||
# объясняет причину (например, 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 с адресом: имя, IP, scur, status.
|
||||
# status стоит в конце, потому что может содержать пробел (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 }'
|
||||
}
|
||||
|
||||
# слоты, которые прерванная замена бросила в drain или maint. Смотрим биты
|
||||
# srv_admin_state 1 (FMAINT) и 8 (FDRAIN); бит 32 ставит сам резолвер, он не
|
||||
# в счёт. По show stat их не отличить: пустой слот в обоих случаях показан
|
||||
# как MAINT (resolution), но ручной maint так и не пустит запросы к
|
||||
# реплике, которая потом займёт этот слот
|
||||
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"])
|
||||
}'
|
||||
}
|
||||
|
||||
# одно поле из вывода slots для IP $1; $2 — номер (1 имя, 3 scur, 4 status)
|
||||
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 контейнеров api, которых не было в снимке $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
|
||||
}
|
||||
|
||||
# ждать до 10 с, пока резолвер LB (hold 1 с) не освободит слот от IP $1
|
||||
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 — вышла сама по SIGTERM, 137 — docker добил её по таймауту
|
||||
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 и обычный stop: только что запущенный процесс сразу
|
||||
# выйдет через ранний обработчик SIGTERM (src/early_stop.py), а успевший
|
||||
# подняться доработает то, что LB отправил ему до maint. Без слота
|
||||
# запросов к ней не было, поэтому годится docker rm -f — он же спасает в
|
||||
# первые миллисекунды старта, пока интерпретатору нечем принять SIGTERM.
|
||||
# Если прервали между up --scale и find_new, 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
|
||||
# ручной drain у живой реплики — след прерванной замены, и make replicas
|
||||
# тут не поможет; поэтому эта проверка идёт до проверки UP
|
||||
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, если проверки нет)
|
||||
# и её слот UP. Слот стартует в 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, ждём scur = 0 (или срок), затем remove_old
|
||||
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
|
||||
|
||||
# финальная сверка: реплик столько же, старых ID нет, все 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
+83
@@ -0,0 +1,83 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Hook отказа для make test-failover (описан в tests/README.md; образец —
|
||||
# scripts/stop-one.example.sh, правила — infra/AGENTS.md).
|
||||
# На входе TARGET_INSTANCE_ID — X-Instance-Id, который вернула реплика; в
|
||||
# compose это hostname, то есть первые символы ID контейнера. Скрипт гасит
|
||||
# одну живую реплику api из своего проекта и обратно её не поднимает:
|
||||
# политика unless-stopped после docker stop и docker kill контейнер не
|
||||
# перезапускает. Хранилища, LB, контейнеры других проектов и volumes не
|
||||
# затрагиваются; вернуть реплику — make replicas.
|
||||
# STOP_MODE=stop (умолчание) — docker stop, процесс успевает завершиться;
|
||||
# STOP_MODE=kill — docker kill, мгновенная смерть без graceful;
|
||||
# STOP_ONE_LOG=<файл> — журнал остановок: в конец файла добавляются
|
||||
# время, TARGET_INSTANCE_ID, полный ID и режим. Вывод hook тест прячет,
|
||||
# а для evidence нужно знать, кого именно остановили.
|
||||
# Ни секретов, ни окружения не выводит. Коды: 2 — плохие аргументы (docker
|
||||
# ещё не вызывался), 3 — подходящей реплики нет.
|
||||
# Проект compose определяется так же, как у docker compose
|
||||
# (COMPOSE_PROJECT_NAME, COMPOSE_FILE и т. п.), по умолчанию — compose.yaml
|
||||
# и .env из корня.
|
||||
|
||||
# проверяем руками, а не через ${VAR:?}: так код 2 одинаков в bash (там
|
||||
# было бы 1) и в 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
|
||||
|
||||
# ожидаем шестнадцатеричный префикс ID длиной 12–64
|
||||
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")/.."
|
||||
|
||||
# ищем префикс среди полных ID запущенных api этого проекта
|
||||
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); --timeout 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