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>
709 lines
29 KiB
Python
Executable File
709 lines
29 KiB
Python
Executable File
#!/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())
|