feat: implement lab 5 queued image processing

This commit is contained in:
2026-11-06 15:08:13 +03:00
parent 276dbdad8a
commit d0ba039f5b
471 changed files with 85827 additions and 24 deletions
+818
View File
@@ -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())
+20
View File
@@ -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
+428
View File
@@ -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"
+83
View File
@@ -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