Files
mtusi2026lab4/student-tests/fault_hook.py
T
ricoromaandClaude Opus 5.5 87c48b940b fix: address upload-consistency verify findings
Mark a stale pending row in its own committed transaction before the
cleaner deletes the object, and let mark_ready promote only unmarked
rows, so a cleaner rollback after the object delete can no longer leave
a ready attachment without its object. Add fault checks for an unknown
COMMIT outcome, an upload outliving the grace period and a cleaner
failure after the object delete; fix the cleaner entrypoint in rules.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 21:27:47 +03:00

709 lines
29 KiB
Python
Executable File
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Hook стенда отказов для проверок `fault` (`make failure_checks`).
Тесты вызывают его как `[FAULT_HOOK, действие, аргументы…]` без shell —
так же `tests/resilience.py` вызывает `ACTION_SCRIPT`. Сами тесты docker
не трогают. Hook работает только с проектом compose из `FAULT_PROJECT`,
его задаёт `student-tests/run_failures.py`. Проект рабочего стенда hook
не трогает. Решение 3 design change `failure-checks`.
Действия:
stop|start|pause|unpause postgres|valkey|s3
flush-cache FLUSHALL
cache-hits keyspace_hits из INFO stats
cache-has-chat <chat_id> EXISTS ключа карточки: 0 или 1
fail-members <title> вставка участников чата с этим названием
падает (триггер в базе стенда отказов)
clear-fail-members убрать триггер
fail-messages <text> вставка сообщения с этим текстом падает
(триггер; ключ идемпотентности к этому
моменту уже вставлен в той же транзакции)
clear-fail-messages убрать триггер
count-chats <title> число чатов с этим названием
fill-connections <секунд> занять все слоты max_connections сессиями
psql (`SELECT pg_sleep`) и оборвать
соединения API: их пулы переподключаются
и получают «too many clients» (53300)
clear-connections освободить слоты и дождаться подключения
db-sessions pg_stat_database.sessions базы стенда:
сколько сессий PostgreSQL приняла за всё
время (учитывает и сессию самого вызова)
attachment-ids строки `<id> <status>` всех вложений базы
стенда
last-pending `id` самого нового вложения в статусе
pending или пусто
object-ids `id` вложений, у которых в bucket стенда
есть объект: файл `original` под
`<база>/attachments/<id>/` (filer через
`weed shell fs.tree` на loopback контейнера
s3). Каталог `<id>` без файла не считается:
после DELETE SeaweedFS убирает его лишь
через ~2 мин
fail-attachments insert|ready|stall|commit|outlive|undeletable <filename>
триггеры на вложения с этим filename (сбой —
SQLSTATE 08006, для API это отказ БД, 503):
insert — вставка строки падает; ready —
перевод в ready падает до COMMIT; stall —
перевод в ready ждёт pg_sleep(4); commit —
перевод в ready падает на COMMIT (исход для
API неизвестен); outlive — строка
вставляется на час старше (уборщик берёт её
сразу), а перевод в ready ждёт до 4,5 с, пока
строка pending не исчезнет; undeletable — как
outlive, и удаление строки падает
clear-fail-attachments убрать триггеры
kill-api docker kill обычного API стенда
(`<FAULT_PROJECT>-api`)
start-api docker start того же контейнера и ожидание
healthy его healthcheck
Bucket и имя базы для object-ids — FAULT_S3_BUCKET и FAULT_DATABASE,
их задаёт run_failures.py. Пароли и ключи не печатает: valkey-cli берёт
пароль из VALKEYCLI_AUTH контейнера, psql работает от POSTGRES_USER
контейнера, weed shell — с ключом подписи из окружения контейнера s3.
Только stdlib. Действия вложений — design change `upload-consistency`,
решение 10.
"""
from __future__ import annotations
import json
import os
import re
import subprocess
import sys
import time
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
COMPOSE_FILES = (
ROOT / "docker-compose.yml",
ROOT / "student-tests" / "failures.compose.yml",
)
PROJECT_SUFFIX = "-failures"
SERVICES = ("postgres", "valkey", "s3")
# та же проверка, что в healthcheck сервиса в docker-compose.yml. У
# PostgreSQL стенда отказов healthcheck переопределён на базу postgres
# (failures.compose.yml), а проба после start / unpause ходит в базу
# приложения и добавляет в её pg_stat_database одну сессию: тест «Соединения
# пула не переоткрываются» start в своём окне не вызывает
PROBES = {
"postgres": 'pg_isready -q -h 127.0.0.1 -U "$POSTGRES_USER" '
'-d "$POSTGRES_DB"',
"valkey": 'test "$(valkey-cli -p "$VALKEY_PORT" ping)" = PONG',
# master выбран, том зарегистрирован у master, filer и шлюз S3
# отвечают — как healthcheck сервиса s3
"s3": "wget -q -O /dev/null http://127.0.0.1:9333/cluster/healthz && "
"wget -q -O - http://127.0.0.1:9333/dir/status | "
"grep -qF '\"DataNodes\":[{' && "
"wget -q -O /dev/null http://127.0.0.1:8888/healthz && "
'wget -q -O /dev/null "http://127.0.0.1:$S3_PORT/healthz"',
}
PROBE_TIMEOUT_S = 30
# начало ключа карточки — копия CACHE_KEY_PREFIX из src/utils/constants.py:
# hook на stdlib и код приложения не импортирует. Меняется формат ключа —
# менять и здесь, иначе упадут test_flush_cache и test_valkey_back
CACHE_KEY_PREFIX = "messenger:v1"
FAIL_MEMBERS_SQL = """\
CREATE OR REPLACE FUNCTION fault_fail_members() RETURNS trigger
LANGUAGE plpgsql AS $$
BEGIN
IF (SELECT title FROM chats WHERE id = NEW.chat_id) = TG_ARGV[0] THEN
RAISE EXCEPTION 'fault injected: chat members insert';
END IF;
RETURN NEW;
END
$$;
DROP TRIGGER IF EXISTS fault_fail_members ON chat_members;
CREATE TRIGGER fault_fail_members BEFORE INSERT ON chat_members
FOR EACH ROW EXECUTE FUNCTION fault_fail_members(:'title');
"""
CLEAR_FAIL_MEMBERS_SQL = """\
DROP TRIGGER IF EXISTS fault_fail_members ON chat_members;
DROP FUNCTION IF EXISTS fault_fail_members();
"""
FAIL_MESSAGES_SQL = """\
CREATE OR REPLACE FUNCTION fault_fail_messages() RETURNS trigger
LANGUAGE plpgsql AS $$
BEGIN
IF NEW.text = TG_ARGV[0] THEN
RAISE EXCEPTION 'fault injected: message insert';
END IF;
RETURN NEW;
END
$$;
DROP TRIGGER IF EXISTS fault_fail_messages ON messages;
CREATE TRIGGER fault_fail_messages BEFORE INSERT ON messages
FOR EACH ROW EXECUTE FUNCTION fault_fail_messages(:'title');
"""
CLEAR_FAIL_MESSAGES_SQL = """\
DROP TRIGGER IF EXISTS fault_fail_messages ON messages;
DROP FUNCTION IF EXISTS fault_fail_messages();
"""
COUNT_CHATS_SQL = "SELECT count(*) FROM chats WHERE title = :'title';\n"
# Сессия psql учитывает себя в sessions, только когда сбросит свои
# счётчики: обычно на первом простое до запроса, но без ожидания
# блокировки, и при занятой — позже. Принудительный сброс в отдельной
# транзакции делает это детерминированным: значение всегда включает
# сессию самого вызова
DB_SESSIONS_SQL = """\
SELECT pg_stat_force_next_flush();
SELECT sessions FROM pg_stat_database WHERE datname = current_database();
"""
# Заполнение слотов: отвязанный sh в контейнере Postgres. Сначала столько
# попыток, сколько слотов, затем новая попытка раз в 0,05 с до конца
# срока: слот, освободившийся после обрыва соединения API, сразу занимает
# снова psql, а не переподключение пула. Лишние попытки получают отказ и
# выходят. Сессии — через сокет ([local]), пользователь контейнера.
# После CLEAR_FILL_SH фоновые psql — сироты пространства PID: их подбирает
# init стенда отказов (init: true у postgres в failures.compose.yml), а не
# postmaster, для которого выход чужого потомка с кодом 2 — авария
FILL_PID = "/tmp/fault-fill.pid"
FILL_SH = f"""\
echo $$ > {FILL_PID}
hold() {{
PGAPPNAME=fault_fill psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -XAtq \\
-c "SELECT pg_sleep($1)" >/dev/null 2>&1 &
}}
end=$(( $(date +%s) + $1 ))
slots=$(psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -XAtq \\
-c 'SHOW max_connections')
i=0
while [ "$i" -lt "$slots" ]; do hold "$1"; i=$((i + 1)); done
while [ "$(date +%s)" -lt "$end" ]; do hold "$1"; sleep 0.05; done
"""
# Обрыв соединений по TCP (это пулы API) сигналом SIGTERM — то же, что
# pg_terminate_backend, но без своего слота. Заголовок процесса backend —
# «postgres: <user> <db> <адрес>(<порт>) <состояние>»; сокет ([local]) и
# проверку готовности с 127.0.0.1 не трогаем. Печатает число оборванных.
KILL_TCP_SH = """\
n=0
for d in /proc/[0-9]*; do
t=$(tr '\\0' ' ' < "$d/cmdline" 2>/dev/null) || continue
case "$t" in
"postgres: "*" 127.0.0.1("*) ;;
"postgres: "*"("*")"*) kill -TERM "${d#/proc/}" 2>/dev/null \\
&& n=$((n + 1)) ;;
esac
done
echo "$n"
"""
CLEAR_FILL_SH = f"""\
[ -f {FILL_PID} ] && kill "$(cat {FILL_PID})" 2>/dev/null
rm -f {FILL_PID}
for d in /proc/[0-9]*; do
t=$(tr '\\0' ' ' < "$d/cmdline" 2>/dev/null) || continue
case "$t" in
"postgres: "*" [local] "*) kill -TERM "${{d#/proc/}}" 2>/dev/null ;;
esac
done
"""
ATTACHMENT_IDS_SQL = """\
SELECT id || ' ' || status FROM attachments ORDER BY created_at, id;
"""
LAST_PENDING_SQL = """\
SELECT id FROM attachments WHERE status = 'pending'
ORDER BY created_at DESC, id DESC LIMIT 1;
"""
# режим и filename — аргументы триггеров (TG_ARGV). SQLSTATE 08006
# (connection_failure) приложение считает отказом БД: 503, а не 500
# (design change upload-consistency, пробы). Три триггера, каждый
# срабатывает только в своих режимах:
# - fault_fail_attachments (строка, BEFORE): insert, ready, stall; в outlive
# и undeletable вставка «на час старше» — created_at и updated_at вместе,
# строка остаётся непомеченной (mark_ready требует updated_at =
# created_at); в undeletable удаление строки падает;
# - fault_fail_attachments_commit (отложенный триггер ограничения, AFTER
# UPDATE): commit — перевод в ready падает на COMMIT, исход для API
# неизвестен;
# - fault_wait_attachments (оператор, BEFORE UPDATE OF status): outlive и
# undeletable — перевод в ready ждёт, пока строка pending с этим
# filename не исчезнет, но не дольше WAIT. На уровне оператора строка ещё
# не заблокирована, уборщик её берёт. UPDATE OF status: пометку уборщика
# (меняет только updated_at) ожидание не задерживает.
# stall и ожидание короче statement_timeout (5 с): завершаются сами
FAIL_ATTACHMENTS_SQL = """\
CREATE OR REPLACE FUNCTION fault_fail_attachments() RETURNS trigger
LANGUAGE plpgsql AS $$
BEGIN
IF TG_OP = 'DELETE' THEN
IF OLD.filename = TG_ARGV[1] AND TG_ARGV[0] = 'undeletable' THEN
RAISE EXCEPTION 'fault injected: attachment delete'
USING ERRCODE = '08006';
END IF;
RETURN OLD;
END IF;
IF NEW.filename <> TG_ARGV[1] THEN
RETURN NEW;
END IF;
IF TG_OP = 'INSERT' THEN
IF TG_ARGV[0] = 'insert' THEN
RAISE EXCEPTION 'fault injected: attachment insert'
USING ERRCODE = '08006';
END IF;
IF TG_ARGV[0] IN ('outlive', 'undeletable') THEN
NEW.created_at := NEW.created_at - interval '1 hour';
NEW.updated_at := NEW.updated_at - interval '1 hour';
END IF;
RETURN NEW;
END IF;
IF OLD.status = 'pending' AND NEW.status = 'ready' THEN
IF TG_ARGV[0] = 'ready' THEN
RAISE EXCEPTION 'fault injected: attachment ready'
USING ERRCODE = '08006';
END IF;
IF TG_ARGV[0] = 'stall' THEN
PERFORM pg_sleep(4);
END IF;
END IF;
RETURN NEW;
END
$$;
CREATE OR REPLACE FUNCTION fault_fail_attachments_commit() RETURNS trigger
LANGUAGE plpgsql AS $$
BEGIN
IF TG_ARGV[0] = 'commit' AND NEW.filename = TG_ARGV[1]
AND OLD.status = 'pending' AND NEW.status = 'ready' THEN
RAISE EXCEPTION 'fault injected: attachment ready commit'
USING ERRCODE = '08006';
END IF;
RETURN NULL;
END
$$;
CREATE OR REPLACE FUNCTION fault_wait_attachments() RETURNS trigger
LANGUAGE plpgsql AS $$
DECLARE
deadline timestamptz := clock_timestamp() + interval '4.5 seconds';
BEGIN
IF TG_ARGV[0] NOT IN ('outlive', 'undeletable') THEN
RETURN NULL;
END IF;
WHILE clock_timestamp() < deadline AND EXISTS (
SELECT 1 FROM attachments
WHERE filename = TG_ARGV[1] AND status = 'pending'
) LOOP
PERFORM pg_sleep(0.1);
END LOOP;
RETURN NULL;
END
$$;
DROP TRIGGER IF EXISTS fault_fail_attachments ON attachments;
CREATE TRIGGER fault_fail_attachments
BEFORE INSERT OR UPDATE OR DELETE ON attachments
FOR EACH ROW EXECUTE FUNCTION fault_fail_attachments(:'mode', :'title');
DROP TRIGGER IF EXISTS fault_fail_attachments_commit ON attachments;
CREATE CONSTRAINT TRIGGER fault_fail_attachments_commit
AFTER UPDATE ON attachments DEFERRABLE INITIALLY DEFERRED
FOR EACH ROW
EXECUTE FUNCTION fault_fail_attachments_commit(:'mode', :'title');
DROP TRIGGER IF EXISTS fault_wait_attachments ON attachments;
CREATE TRIGGER fault_wait_attachments
BEFORE UPDATE OF status ON attachments
FOR EACH STATEMENT
EXECUTE FUNCTION fault_wait_attachments(:'mode', :'title');
"""
CLEAR_FAIL_ATTACHMENTS_SQL = """\
DROP TRIGGER IF EXISTS fault_fail_attachments ON attachments;
DROP TRIGGER IF EXISTS fault_fail_attachments_commit ON attachments;
DROP TRIGGER IF EXISTS fault_wait_attachments ON attachments;
DROP FUNCTION IF EXISTS fault_fail_attachments();
DROP FUNCTION IF EXISTS fault_fail_attachments_commit();
DROP FUNCTION IF EXISTS fault_wait_attachments();
"""
FAIL_ATTACHMENTS_MODES = (
"insert",
"ready",
"stall",
"commit",
"outlive",
"undeletable",
)
# как S3_BUCKET_NAME_PATTERN в src/utils/constants.py; имя базы — как в
# run_isolated.py: путь filer собирается только из проверенных имён
BUCKET_NAME_RE = re.compile(r"^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$")
DB_NAME_RE = re.compile(r"^[a-z0-9_]+$")
# каталог вложения в filer — его id; копия ATTACHMENT_KEY_PREFIX и
# ATTACHMENT_ORIGINAL_SUFFIX из src/utils/constants.py
ATTACHMENT_DIR_RE = re.compile(
r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
)
ATTACHMENT_KEY_PREFIX = "attachments"
ATTACHMENT_ORIGINAL = "original"
# строка fs.tree: отступ по 4 символа на уровень («│ » или « »), затем
# «├──» или «└──» и имя
TREE_LINE_RE = re.compile(r"^((?:[│ ] {3})*)[├└]──\s*(.*?)\s*$")
API_HEALTHY_TIMEOUT_S = 60
PROBE_SQL_SH = (
'exec psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -XAtq -c "SELECT 1"'
)
TOO_MANY = "too many clients"
FILL_TIMEOUT_S = 20
class HookError(Exception):
"""Неверный вызов или проект: код 2 и сообщение в stderr."""
def working_project() -> str:
"""Имя проекта рабочего стенда — из docker-compose.yml без `-p`."""
result = subprocess.run(
["docker", "compose", "config", "--format", "json"],
cwd=ROOT,
text=True,
capture_output=True,
check=True,
)
return json.loads(result.stdout)["name"]
def fault_project() -> str:
project = os.environ.get("FAULT_PROJECT", "")
if not project.endswith(PROJECT_SUFFIX):
raise HookError(
f"FAULT_PROJECT must end with {PROJECT_SUFFIX!r}: "
"run make failure_checks",
)
if project == working_project():
raise HookError("FAULT_PROJECT is the working stand, refusing")
return project
def compose_run(
project: str,
*args: str,
stdin: str | None = None,
) -> subprocess.CompletedProcess[str]:
files = [arg for path in COMPOSE_FILES for arg in ("-f", str(path))]
return subprocess.run(
["docker", "compose", "-p", project, *files, *args],
cwd=ROOT,
input=stdin,
text=True,
capture_output=True,
check=False,
)
def compose(project: str, *args: str, stdin: str | None = None) -> str:
result = compose_run(project, *args, stdin=stdin)
if result.returncode != 0:
sys.stderr.write(result.stderr)
raise SystemExit(result.returncode)
return result.stdout.strip()
def wait_answers(project: str, name: str) -> str:
"""Ждать, пока сервис ответит своей проверкой из healthcheck.
После `unpause` Docker до следующего запуска healthcheck (до 5 с)
показывает `unhealthy`, и `up --wait` сразу выходит с ошибкой, хотя
сервис уже отвечает. Поэтому проверка — напрямую.
"""
deadline = time.monotonic() + PROBE_TIMEOUT_S
while time.monotonic() < deadline:
probe = compose_run(
project,
"exec",
"-T",
name,
"sh",
"-c",
PROBES[name],
)
if probe.returncode == 0:
return ""
time.sleep(0.2)
raise HookError(f"{name} does not answer in {PROBE_TIMEOUT_S}s")
def valkey(project: str, *args: str) -> str:
# аргументы — позиционные параметры sh, без подстановки в строку
return compose(
project,
"exec",
"-T",
"valkey",
"sh",
"-c",
'exec valkey-cli -p "$VALKEY_PORT" "$@"',
"sh",
*args,
)
def psql(project: str, sql: str, *, title: str = "", mode: str = "") -> str:
# значения — переменные psql (:'title', :'mode'), без подстановки в SQL
return compose(
project,
"exec",
"-T",
"postgres",
"sh",
"-c",
'exec psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -XAtq '
'-v ON_ERROR_STOP=1 -v title="$1" -v mode="$2"',
"sh",
title,
mode,
stdin=sql,
)
def service(name: str) -> str:
if name not in SERVICES:
raise HookError(f"service must be one of {SERVICES}")
return name
def wait_healthy(project: str, name: str) -> str:
# тот же контейнер, без пересоздания; --wait ждёт его healthcheck
return compose(project, "up", "-d", "--wait", "--no-recreate", name)
def cache_hits(project: str) -> str:
for line in valkey(project, "INFO", "stats").splitlines():
if line.startswith("keyspace_hits:"):
return line.split(":", 1)[1].strip()
raise HookError("keyspace_hits not found in INFO stats")
def cache_has_chat(project: str, chat_id: str) -> str:
database = compose(
project,
"exec",
"-T",
"postgres",
"printenv",
"POSTGRES_DB",
)
key = f"{CACHE_KEY_PREFIX}:{database}:chat:{uuid.UUID(chat_id)}"
return valkey(project, "EXISTS", key)
def postgres_sh(project: str, script: str, *args: str) -> str:
return compose(
project,
"exec",
"-T",
"postgres",
"sh",
"-c",
script,
"sh",
*args,
)
def probe_connect(project: str) -> subprocess.CompletedProcess[str]:
"""Новое подключение psql и `SELECT 1`."""
return compose_run(
project,
"exec",
"-T",
"postgres",
"sh",
"-c",
PROBE_SQL_SH,
)
def slots_full(project: str) -> bool:
"""Новое подключение получает «too many clients»."""
probe = probe_connect(project)
return probe.returncode != 0 and TOO_MANY in probe.stderr
def fill_connections(project: str, seconds: str) -> str:
"""Все слоты заняты psql, соединений API не осталось.
Готово, когда новое подключение получает отказ, а обрывать уже
некого: пул API, переподключаясь, получит 53300.
"""
if int(seconds) <= 0:
raise HookError("seconds must be positive")
compose(
project,
"exec",
"-d",
"postgres",
"sh",
"-c",
FILL_SH,
"sh",
str(int(seconds)),
)
deadline = time.monotonic() + FILL_TIMEOUT_S
while time.monotonic() < deadline:
if slots_full(project) and postgres_sh(project, KILL_TCP_SH) == "0":
return ""
time.sleep(0.1)
raise HookError(f"connections are not filled in {FILL_TIMEOUT_S}s")
def clear_connections(project: str) -> str:
deadline = time.monotonic() + FILL_TIMEOUT_S
while time.monotonic() < deadline:
postgres_sh(project, CLEAR_FILL_SH)
if probe_connect(project).returncode == 0:
return ""
time.sleep(0.2)
raise HookError(f"connections are not freed in {FILL_TIMEOUT_S}s")
def ids_with_original(tree: str) -> list[str]:
"""`id` каталогов первого уровня, в которых есть файл `original`.
Вывод `fs.tree` каталога `attachments`: первая строка — сам каталог,
затем `├──<id>` и под ним `│ └──original`. Каталог `<id>` без файла
— остаток после DELETE, объекта в нём нет.
"""
found: list[str] = []
current = ""
for line in tree.splitlines():
match = TREE_LINE_RE.match(line)
if match is None:
continue
depth = len(match.group(1)) // 4 + 1
name = match.group(2)
if depth == 1:
current = name if ATTACHMENT_DIR_RE.fullmatch(name) else ""
elif depth == 2 and name == ATTACHMENT_ORIGINAL and current:
found.append(current)
return found
def object_ids(project: str) -> str:
"""`id` вложений с объектом в bucket стенда, строка на `id`. Нет
префикса — пусто."""
bucket = os.environ.get("FAULT_S3_BUCKET", "")
database = os.environ.get("FAULT_DATABASE", "")
if not BUCKET_NAME_RE.fullmatch(bucket):
raise HookError(f"FAULT_S3_BUCKET is not a bucket name: {bucket!r}")
if not DB_NAME_RE.fullmatch(database):
raise HookError(f"FAULT_DATABASE is not a database name: {database!r}")
tree = compose(
project,
"exec",
"-T",
"s3",
"sh",
"-c",
"exec weed shell -master=127.0.0.1:9333 2>&1",
stdin=(
f"fs.tree /buckets/{bucket}/{database}/{ATTACHMENT_KEY_PREFIX}\n"
),
)
return "\n".join(ids_with_original(tree))
def fail_attachments(project: str, mode: str, filename: str) -> str:
if mode not in FAIL_ATTACHMENTS_MODES:
raise HookError(f"mode must be one of {FAIL_ATTACHMENTS_MODES}")
return psql(project, FAIL_ATTACHMENTS_SQL, title=filename, mode=mode)
def api_container(project: str) -> str:
# обычный API стенда отказов: имя задаёт run_failures.py
return f"{project}-api"
def start_api(project: str) -> str:
"""Тот же контейнер API; готов — `healthy` по healthcheck образа."""
name = api_container(project)
docker("start", name)
deadline = time.monotonic() + API_HEALTHY_TIMEOUT_S
while time.monotonic() < deadline:
status = docker(
"inspect",
"-f",
"{{.State.Health.Status}}",
name,
)
if status == "healthy":
return ""
time.sleep(0.2)
raise HookError(f"{name} is not healthy in {API_HEALTHY_TIMEOUT_S}s")
def docker(*args: str) -> str:
result = subprocess.run(
["docker", *args],
text=True,
capture_output=True,
check=False,
)
if result.returncode != 0:
sys.stderr.write(result.stderr)
raise SystemExit(result.returncode)
return result.stdout.strip()
def run(project: str, action: str, args: list[str]) -> str:
"""Выполнить действие; синтаксис без match: hook запускают и 3.9."""
if action in ("stop", "pause") and len(args) == 1:
return compose(project, action, service(args[0]))
if action == "start" and len(args) == 1:
return wait_healthy(project, service(args[0]))
if action == "unpause" and len(args) == 1:
compose(project, "unpause", service(args[0]))
return wait_answers(project, args[0])
if action == "flush-cache" and not args:
return valkey(project, "FLUSHALL")
if action == "cache-hits" and not args:
return cache_hits(project)
if action == "cache-has-chat" and len(args) == 1:
return cache_has_chat(project, args[0])
if action == "fail-members" and len(args) == 1:
return psql(project, FAIL_MEMBERS_SQL, title=args[0])
if action == "clear-fail-members" and not args:
return psql(project, CLEAR_FAIL_MEMBERS_SQL)
if action == "fail-messages" and len(args) == 1:
# аргумент триггера передаётся той же переменной psql, что title
return psql(project, FAIL_MESSAGES_SQL, title=args[0])
if action == "clear-fail-messages" and not args:
return psql(project, CLEAR_FAIL_MESSAGES_SQL)
if action == "count-chats" and len(args) == 1:
return psql(project, COUNT_CHATS_SQL, title=args[0])
if action == "fill-connections" and len(args) == 1:
return fill_connections(project, args[0])
if action == "clear-connections" and not args:
return clear_connections(project)
if action == "db-sessions" and not args:
return psql(project, DB_SESSIONS_SQL)
if action == "attachment-ids" and not args:
return psql(project, ATTACHMENT_IDS_SQL)
if action == "last-pending" and not args:
return psql(project, LAST_PENDING_SQL)
if action == "object-ids" and not args:
return object_ids(project)
if action == "fail-attachments" and len(args) == 2:
return fail_attachments(project, args[0], args[1])
if action == "clear-fail-attachments" and not args:
return psql(project, CLEAR_FAIL_ATTACHMENTS_SQL)
if action == "kill-api" and not args:
return docker("kill", api_container(project)) and ""
if action == "start-api" and not args:
return start_api(project)
raise HookError(f"unknown action or arguments: {action} {args}")
def main() -> int:
if len(sys.argv) < 2:
print(__doc__, file=sys.stderr)
return 2
try:
output = run(fault_project(), sys.argv[1], sys.argv[2:])
except (HookError, ValueError) as e:
print(f"fault_hook: {e}", file=sys.stderr)
return 2
if output:
print(output)
return 0
if __name__ == "__main__":
sys.exit(main())