252 lines
9.6 KiB
Python
Executable File
252 lines
9.6 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/stand.py` через окружение) и
|
|
отказывается работать с проектом рабочего стенда.
|
|
|
|
Действия:
|
|
stop|start|pause|unpause postgres|valkey
|
|
flush-cache FLUSHALL
|
|
cache-hits keyspace_hits из INFO stats
|
|
cache-has-chat <chat_id> EXISTS ключа карточки: 0 или 1
|
|
fail-members <title> вставка участников чата с этим названием
|
|
падает (триггер в базе стенда отказов)
|
|
clear-fail-members убрать триггер
|
|
count-chats <title> число чатов с этим названием
|
|
fail-messages <text> вставка сообщения с этим текстом падает —
|
|
уже после вставки ключа идемпотентности
|
|
clear-fail-messages убрать триггер
|
|
count-keys <chat_id> число ключей идемпотентности чата
|
|
|
|
Пароли не печатает: valkey-cli берёт пароль из VALKEYCLI_AUTH
|
|
контейнера, psql работает от POSTGRES_USER контейнера. Только stdlib,
|
|
Python 3.9+.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import uuid
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
COMPOSE_FILES = (ROOT / "compose.yaml", ROOT / "student-tests" / "stand.compose.yml")
|
|
ENV_FILE = ROOT / "student-tests" / "stand.env"
|
|
PROJECT_SUFFIX = "-failures"
|
|
SERVICES = ("postgres", "valkey")
|
|
# та же проверка, что healthcheck сервиса в compose.yaml
|
|
PROBES = {
|
|
"postgres": 'pg_isready -q -h 127.0.0.1 -U "$POSTGRES_USER" -d "$POSTGRES_DB"',
|
|
"valkey": 'test "$(valkey-cli ping)" = PONG',
|
|
}
|
|
PROBE_TIMEOUT = 30
|
|
# начало ключа карточки — копия CACHE_KEY_PREFIX из src/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(:'arg');
|
|
"""
|
|
CLEAR_FAIL_MEMBERS_SQL = """\
|
|
DROP TRIGGER IF EXISTS fault_fail_members ON chat_members;
|
|
DROP FUNCTION IF EXISTS fault_fail_members();
|
|
"""
|
|
COUNT_CHATS_SQL = "SELECT count(*) FROM chats WHERE title = :'arg';\n"
|
|
# сбой вставки сообщения: ключ идемпотентности к этому моменту уже вставлен
|
|
# той же транзакцией (src/storage/postgres.py) — откат должен убрать и его
|
|
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(:'arg');
|
|
"""
|
|
CLEAR_FAIL_MESSAGES_SQL = """\
|
|
DROP TRIGGER IF EXISTS fault_fail_messages ON messages;
|
|
DROP FUNCTION IF EXISTS fault_fail_messages();
|
|
"""
|
|
COUNT_KEYS_SQL = "SELECT count(*) FROM idempotency_keys WHERE chat_id = :'arg';\n"
|
|
|
|
|
|
class HookError(Exception):
|
|
"""Неверный вызов или проект: код 2 и сообщение в stderr."""
|
|
|
|
|
|
def fault_project() -> str:
|
|
project = os.environ.get("FAULT_PROJECT", "")
|
|
if not project.endswith(PROJECT_SUFFIX) or project == PROJECT_SUFFIX:
|
|
raise HookError(
|
|
f"FAULT_PROJECT must end with {PROJECT_SUFFIX!r}: run make failure-checks",
|
|
)
|
|
return project
|
|
|
|
|
|
def compose_run(project: str, *args: str, stdin: str | None = None):
|
|
files = [arg for path in COMPOSE_FILES for arg in ("-f", str(path))]
|
|
return subprocess.run(
|
|
[
|
|
"docker",
|
|
"compose",
|
|
"-p",
|
|
project,
|
|
"--env-file",
|
|
str(ENV_FILE),
|
|
*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 service(name: str) -> str:
|
|
if name not in SERVICES:
|
|
raise HookError(f"service must be one of {SERVICES}")
|
|
return name
|
|
|
|
|
|
def wait_answers(project: str, name: str) -> str:
|
|
"""Ждать, пока сервис ответит проверкой из своего healthcheck.
|
|
|
|
После `unpause` Docker до следующего запуска healthcheck показывает
|
|
старое состояние, и `up --wait` выходит с ошибкой, хотя сервис уже
|
|
отвечает. Поэтому проверка — напрямую.
|
|
"""
|
|
deadline = time.monotonic() + PROBE_TIMEOUT
|
|
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")
|
|
|
|
|
|
def valkey(project: str, *args: str) -> str:
|
|
# аргументы — позиционные параметры sh, без подстановки в строку
|
|
return compose(
|
|
project,
|
|
"exec",
|
|
"-T",
|
|
"valkey",
|
|
"sh",
|
|
"-c",
|
|
'exec valkey-cli "$@"',
|
|
"sh",
|
|
*args,
|
|
)
|
|
|
|
|
|
def psql(project: str, sql: str, *, arg: str = "") -> str:
|
|
# аргумент — переменная psql :'arg' (литерал в SQL экранирует сам psql)
|
|
return compose(
|
|
project,
|
|
"exec",
|
|
"-T",
|
|
"postgres",
|
|
"sh",
|
|
"-c",
|
|
'exec psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -XAtq '
|
|
'-v ON_ERROR_STOP=1 -v arg="$1"',
|
|
"sh",
|
|
arg,
|
|
stdin=sql,
|
|
)
|
|
|
|
|
|
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 run(project: str, action: str, args: list[str]) -> str:
|
|
"""Выполнить действие; без match: hook запускается и на Python 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:
|
|
# тот же контейнер, без пересоздания; --wait ждёт его healthcheck
|
|
return compose(project, "up", "-d", "--wait", "--no-recreate", 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, arg=args[0])
|
|
if action == "clear-fail-members" and not args:
|
|
return psql(project, CLEAR_FAIL_MEMBERS_SQL)
|
|
if action == "count-chats" and len(args) == 1:
|
|
return psql(project, COUNT_CHATS_SQL, arg=args[0])
|
|
if action == "fail-messages" and len(args) == 1:
|
|
return psql(project, FAIL_MESSAGES_SQL, arg=args[0])
|
|
if action == "clear-fail-messages" and not args:
|
|
return psql(project, CLEAR_FAIL_MESSAGES_SQL)
|
|
if action == "count-keys" and len(args) == 1:
|
|
return psql(project, COUNT_KEYS_SQL, arg=str(uuid.UUID(args[0])))
|
|
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 exc:
|
|
print(f"fault_hook: {exc}", file=sys.stderr)
|
|
return 2
|
|
if output:
|
|
print(output)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|