forked from mtusi2026/mtusi2026lab4
Добавить вложения: S3, метаданные в PostgreSQL и очистка незавершённых загрузок
This commit is contained in:
Executable
+23
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Сценарий защиты: файл, сообщение, чужой пользователь, прямой доступ к S3. Запускать из корня репозитория."""
|
||||
import hashlib
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, "student-tests")
|
||||
from api import call, new_chat, new_user, request_bytes, send
|
||||
data = Path("tests/fixtures/sample.png").read_bytes()
|
||||
alice, bob, eve = new_user("alice"), new_user("bob"), new_user("eve")
|
||||
chat = new_chat(alice, bob)
|
||||
_, att, _ = call("POST", "/api/v1/chats/%s/attachments?filename=sample.png" % chat["id"], raw=data, user=alice, headers={"Content-Type": "image/png"})
|
||||
print("загрузка:", att["status"], att["size_bytes"], "байт, sha256", att["sha256"][:16])
|
||||
status, msg, _ = send(alice, chat, "смотри файл", attachment_ids=[att["id"]])
|
||||
print("сообщение:", status, "attachment_ids =", len(msg["attachment_ids"]))
|
||||
status, body, headers = request_bytes("GET", "/api/v1/attachments/%s/content" % att["id"], user=bob)
|
||||
print("второй участник скачал:", status, headers.get_content_type(), "sha256 совпал:", hashlib.sha256(body).hexdigest() == hashlib.sha256(data).hexdigest())
|
||||
print("посторонний, метаданные:", call("GET", "/api/v1/attachments/" + att["id"], user=eve)[0], " байты:", request_bytes("GET", "/api/v1/attachments/%s/content" % att["id"], user=eve)[0])
|
||||
code = "import urllib.request,urllib.error\ntry:\n print(urllib.request.urlopen('http://s3:9000/messenger-attachments/originals/%s',timeout=3).status)\nexcept urllib.error.HTTPError as e:\n print(e.code)" % att["id"]
|
||||
cid = subprocess.run(["docker","compose","--env-file",".env","ps","-q","api"],capture_output=True,text=True).stdout.split()[0]
|
||||
out = subprocess.run(["docker","exec",cid,"python","-c",code],capture_output=True,text=True).stdout.strip()
|
||||
print("прямой GET в S3 без подписи изнутри сети:", out)
|
||||
@@ -0,0 +1,245 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Нагрузка записью через балансировщик во время отказа или замены реплик.
|
||||
|
||||
stop — по очереди останавливает каждую реплику (SIGTERM), восстанавливая предыдущую;
|
||||
kill — то же, но SIGKILL, без корректного завершения;
|
||||
pause — то же, но реплика зависает (docker pause): соединения открыты, ответов нет;
|
||||
rolling — запускает scripts/rolling-update.sh.
|
||||
|
||||
Клиент ведёт себя как в контракте: при неопределённом ответе повторяет запрос с тем же ключом.
|
||||
В конце вся история сверяется с подтверждёнными сообщениями.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "student-tests"))
|
||||
from api import call, history, new_chat, new_user, send
|
||||
|
||||
WORKERS = 4
|
||||
|
||||
|
||||
def compose(*args):
|
||||
command = ["docker", "compose", "--env-file", ".env", *args]
|
||||
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout
|
||||
|
||||
|
||||
def api_containers():
|
||||
return compose("ps", "-q", "api").split()
|
||||
|
||||
|
||||
def wait_ready(seconds=60):
|
||||
deadline = time.monotonic() + seconds
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
if call("GET", "/health/ready", timeout=2)[0] == 200:
|
||||
return
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(0.2)
|
||||
raise SystemExit("стенд не стал готов")
|
||||
|
||||
|
||||
def wait_replicas(count):
|
||||
"""Ждёт, пока балансировщик начнёт отдавать запросы на count разных реплик."""
|
||||
deadline = time.monotonic() + 30
|
||||
while time.monotonic() < deadline:
|
||||
seen = {call("GET", "/health/live", timeout=2)[2]["X-Instance-Id"] for _ in range(count * 4)}
|
||||
if len(seen) >= count:
|
||||
return
|
||||
time.sleep(0.2)
|
||||
raise SystemExit("балансировщик не видит %d реплик" % count)
|
||||
|
||||
|
||||
class Load:
|
||||
"""Несколько клиентов пишут в один чат, каждое событие сохраняется с отметкой времени."""
|
||||
|
||||
def __init__(self):
|
||||
self.user = new_user("chaos")
|
||||
self.chat = new_chat(self.user)
|
||||
self.stop = threading.Event()
|
||||
self.events = [] # (время, ok, реплика, статус)
|
||||
self.confirmed = {}
|
||||
self.lock = threading.Lock()
|
||||
self.threads = [threading.Thread(target=self.worker, args=(n,)) for n in range(WORKERS)]
|
||||
|
||||
def worker(self, number):
|
||||
index = 0
|
||||
while not self.stop.is_set():
|
||||
text = "worker-%d-%d-%s" % (number, index, uuid.uuid4().hex[:8])
|
||||
key = uuid.uuid4().hex
|
||||
index += 1
|
||||
while True:
|
||||
try:
|
||||
status, body, headers = send(self.user, self.chat, text, key=key, timeout=3)
|
||||
instance = headers.get("X-Instance-Id")
|
||||
except OSError:
|
||||
status, body, instance = 0, None, None
|
||||
now = time.monotonic()
|
||||
ok = status == 201
|
||||
with self.lock:
|
||||
self.events.append((now, ok, instance, status))
|
||||
if ok:
|
||||
self.confirmed[body["id"]] = body
|
||||
if ok or self.stop.is_set():
|
||||
break
|
||||
time.sleep(0.05) # неопределённый результат: тот же текст и тот же ключ
|
||||
|
||||
def start(self):
|
||||
for thread in self.threads:
|
||||
thread.start()
|
||||
|
||||
def finish(self):
|
||||
self.stop.set()
|
||||
for thread in self.threads:
|
||||
thread.join()
|
||||
|
||||
|
||||
def percentile(values, p):
|
||||
ordered = sorted(values)
|
||||
return round(ordered[max(0, math.ceil(p * len(ordered)) - 1)], 3) if ordered else None
|
||||
|
||||
|
||||
def summary(events, started, action_at, target=None):
|
||||
"""Показатели одного интервала: от action_at считается время до восстановления записи."""
|
||||
ok = [e for e in events if e[1]]
|
||||
failed = [e for e in events if not e[1]]
|
||||
elapsed = events[-1][0] - started
|
||||
gaps = [b[0] - a[0] for a, b in zip(ok, ok[1:])]
|
||||
after = [e for e in ok if e[0] >= action_at]
|
||||
last_on_target = [e[0] for e in ok if target and e[2] and target.startswith(e[2])]
|
||||
return {
|
||||
"seconds": round(elapsed, 2),
|
||||
"successful_requests": len(ok),
|
||||
"failed_attempts": len(failed),
|
||||
"failed_statuses": sorted({e[3] for e in failed}),
|
||||
"successful_rps": round(len(ok) / elapsed, 1),
|
||||
"longest_gap_between_successes_s": round(max(gaps), 3) if gaps else None,
|
||||
"first_success_after_action_s": round(after[0][0] - action_at, 3) if after else None,
|
||||
"last_success_on_target_after_action_s": round(last_on_target[-1] - action_at, 3)
|
||||
if last_on_target and last_on_target[-1] >= action_at else None,
|
||||
"instances_seen": len({e[2] for e in ok}),
|
||||
}
|
||||
|
||||
|
||||
def verify(load):
|
||||
items, _ = history(load.user, load.chat, 100)
|
||||
by_id = {item["id"]: item for item in items}
|
||||
texts = [item["text"] for item in items]
|
||||
lost = [mid for mid, message in load.confirmed.items() if by_id.get(mid) != message]
|
||||
result = {
|
||||
"confirmed": len(load.confirmed),
|
||||
"in_history": len(items),
|
||||
"lost_confirmed": len(lost),
|
||||
"duplicate_ids": len(items) - len(by_id),
|
||||
"duplicate_texts": len(texts) - len(set(texts)),
|
||||
}
|
||||
result["unconfirmed_but_saved"] = len(items) - len(load.confirmed)
|
||||
return result
|
||||
|
||||
|
||||
def replicas_up():
|
||||
"""Сколько реплик балансировщик считает рабочими, по его странице статистики."""
|
||||
csv = compose("exec", "-T", "lb", "wget", "-q", "-O", "-", "http://127.0.0.1:8404/stats;csv")
|
||||
return sum(line.startswith("api,api") and ",UP" in line for line in csv.splitlines())
|
||||
|
||||
|
||||
def seconds_until_excluded(replicas, since, limit=8):
|
||||
while time.monotonic() - since < limit:
|
||||
if replicas_up() < replicas:
|
||||
return round(time.monotonic() - since, 2)
|
||||
time.sleep(0.1)
|
||||
return None
|
||||
|
||||
|
||||
def replica_round(signal):
|
||||
containers = api_containers()
|
||||
wait_replicas(len(containers))
|
||||
rounds = []
|
||||
for container in containers:
|
||||
load = Load()
|
||||
started = time.monotonic()
|
||||
load.start()
|
||||
time.sleep(5)
|
||||
action_at = time.monotonic()
|
||||
command = {"SIGTERM": "stop", "SIGKILL": "kill", "HANG": "pause"}[signal]
|
||||
subprocess.run(["docker", command, container], check=True, stdout=subprocess.DEVNULL)
|
||||
stop_took = time.monotonic() - action_at
|
||||
excluded_after = seconds_until_excluded(len(containers), action_at)
|
||||
time.sleep(max(0, 10 - (time.monotonic() - action_at)))
|
||||
command = "unpause" if signal == "HANG" else "start"
|
||||
subprocess.run(["docker", command, container], check=True, stdout=subprocess.DEVNULL)
|
||||
wait_replicas(len(containers))
|
||||
time.sleep(2)
|
||||
load.finish()
|
||||
result = summary(load.events, started, action_at, container)
|
||||
result.update({"target": container[:12], "signal": signal, "stop_command_s": round(stop_took, 2),
|
||||
"excluded_by_lb_after_s": excluded_after})
|
||||
result["verify"] = verify(load)
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
rounds.append(result)
|
||||
return rounds
|
||||
|
||||
|
||||
def images():
|
||||
inspect = ["docker", "inspect", "-f", "{{.Image}}"]
|
||||
return {c[:12]: subprocess.check_output(inspect + [c], text=True).strip()[:19] for c in api_containers()}
|
||||
|
||||
|
||||
def rolling_round():
|
||||
before = images()
|
||||
wait_replicas(len(before))
|
||||
load = Load()
|
||||
started = time.monotonic()
|
||||
load.start()
|
||||
time.sleep(5)
|
||||
action_at = time.monotonic()
|
||||
subprocess.run(["./scripts/rolling-update.sh"], cwd=ROOT, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
update_took = time.monotonic() - action_at
|
||||
time.sleep(5)
|
||||
load.finish()
|
||||
after = images()
|
||||
result = summary(load.events, started, action_at)
|
||||
result.update({"update_seconds": round(update_took, 2), "containers_before": before, "containers_after": after,
|
||||
"app_version": os.environ.get("APP_VERSION", "dev")})
|
||||
result["verify"] = verify(load)
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
# без этой проверки скрипт, который ничего не заменил, выглядел бы как идеальное обновление
|
||||
if set(before) & set(after) or set(before.values()) & set(after.values()) or len(after) != len(before):
|
||||
raise SystemExit("FAIL: реплики не заменены новым образом")
|
||||
return [result]
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument("mode", choices=["stop", "kill", "pause", "rolling"])
|
||||
parser.add_argument("--output")
|
||||
args = parser.parse_args()
|
||||
wait_ready()
|
||||
if args.mode == "rolling":
|
||||
rounds = rolling_round()
|
||||
else:
|
||||
rounds = replica_round({"stop": "SIGTERM", "kill": "SIGKILL", "pause": "HANG"}[args.mode])
|
||||
report = {
|
||||
"workload": "%d клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом" % WORKERS,
|
||||
"mode": args.mode,
|
||||
"rounds": rounds,
|
||||
}
|
||||
if args.output:
|
||||
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
bad = [r for r in rounds if r["verify"]["lost_confirmed"] or r["verify"]["duplicate_ids"] or r["verify"]["duplicate_texts"]]
|
||||
if bad:
|
||||
raise SystemExit("FAIL: потеряны или продублированы сообщения")
|
||||
print("PASS: подтверждённые сообщения на месте, дублей нет")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+11
@@ -0,0 +1,11 @@
|
||||
#!/bin/sh
|
||||
# Наполняет БД синтетической историей и печатает планы запросов пагинации.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
run_sql() {
|
||||
docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 -q
|
||||
}
|
||||
|
||||
run_sql < scripts/seed_history.sql
|
||||
run_sql < scripts/explain_history.sql
|
||||
@@ -0,0 +1,56 @@
|
||||
\set chat '00000000-0000-4000-8000-000000000100'
|
||||
\pset pager off
|
||||
|
||||
\echo '== Объём данных'
|
||||
SELECT count(*) AS messages_total,
|
||||
count(*) FILTER (WHERE chat_id = :'chat') AS messages_in_chat,
|
||||
pg_size_pretty(pg_relation_size('messages')) AS table_size,
|
||||
pg_size_pretty(pg_relation_size('messages_chat_history_idx')) AS index_size
|
||||
FROM messages;
|
||||
|
||||
\echo
|
||||
\echo '== 1. Первая страница (limit 50, запрос берёт 51 строку)'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = messages.id), '{}'::uuid[]) AS attachment_ids
|
||||
FROM messages
|
||||
WHERE chat_id = :'chat'
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
-- cursor на 5000-е сообщение чата, как его получил бы клиент после 100 страниц
|
||||
SELECT created_at AS after_time, id AS after_id FROM messages
|
||||
WHERE chat_id = :'chat' ORDER BY created_at, id OFFSET 4999 LIMIT 1 \gset
|
||||
|
||||
\echo
|
||||
\echo '== 2. Страница из середины истории: keyset после 5000-го сообщения'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = messages.id), '{}'::uuid[]) AS attachment_ids
|
||||
FROM messages
|
||||
WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id')
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
\echo
|
||||
\echo '== 3. Та же страница через OFFSET (так делать не стали)'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = messages.id), '{}'::uuid[]) AS attachment_ids
|
||||
FROM messages
|
||||
WHERE chat_id = :'chat'
|
||||
ORDER BY created_at, id OFFSET 5000 LIMIT 51;
|
||||
|
||||
\echo
|
||||
\echo '== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK)'
|
||||
BEGIN;
|
||||
DROP INDEX messages_chat_history_idx;
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at,
|
||||
COALESCE((SELECT array_agg(a.attachment_id ORDER BY a.position) FROM message_attachments a
|
||||
WHERE a.message_id = messages.id), '{}'::uuid[]) AS attachment_ids
|
||||
FROM messages
|
||||
WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id')
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
ROLLBACK;
|
||||
Executable
+32
@@ -0,0 +1,32 @@
|
||||
#!/bin/sh
|
||||
# Создаёт .env из .env.example и дописывает в него случайные пароли. Файл .env исключён из Git.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
[ -f .env ] || cp .env.example .env
|
||||
|
||||
if grep -q '^POSTGRES_PASSWORD=' .env; then
|
||||
# пароль PostgreSQL задаётся один раз при создании volume, новый пароль к старым данным не подойдёт
|
||||
echo ".env уже содержит пароли, ничего не меняю"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
postgres_password=$(openssl rand -hex 24)
|
||||
redis_password=$(openssl rand -hex 24)
|
||||
key() { openssl rand -hex "$1"; }
|
||||
cat >> .env <<END
|
||||
|
||||
# Локальные секреты, созданы scripts/init-env.sh. Compose кладёт их в контейнеры файлами /run/secrets/*.
|
||||
POSTGRES_PASSWORD=$postgres_password
|
||||
REDIS_PASSWORD=$redis_password
|
||||
DATABASE_URL=postgresql://messenger:$postgres_password@postgres:5432/messenger
|
||||
CACHE_URL=redis://:$redis_password@redis:6379/0
|
||||
S3_ADMIN_ACCESS_KEY_ID=$(key 12)
|
||||
S3_ADMIN_SECRET_ACCESS_KEY=$(key 24)
|
||||
S3_ACCESS_KEY_ID=$(key 12)
|
||||
S3_SECRET_ACCESS_KEY=$(key 24)
|
||||
S3_JANITOR_ACCESS_KEY_ID=$(key 12)
|
||||
S3_JANITOR_SECRET_ACCESS_KEY=$(key 24)
|
||||
END
|
||||
chmod 600 .env
|
||||
echo "пароли записаны в .env"
|
||||
Executable
+14
@@ -0,0 +1,14 @@
|
||||
#!/bin/sh
|
||||
# Перезапускает балансировщик, все реплики API, janitor и все хранилища. Volumes не трогает.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres redis s3 api janitor lb
|
||||
|
||||
# /health/ready от S3 не зависит, поэтому готовность S3 ждём здесь: том данных появляется за 20-30 секунд
|
||||
container=$(docker compose --env-file .env ps -q s3)
|
||||
for attempt in $(seq 1 80); do
|
||||
[ "$(docker inspect -f '{{.State.Health.Status}}' "$container")" = healthy ] && exit 0
|
||||
sleep 1
|
||||
done
|
||||
echo "S3 не стал готов за 80 секунд" >&2
|
||||
exit 1
|
||||
Executable
+38
@@ -0,0 +1,38 @@
|
||||
#!/bin/sh
|
||||
# Поочерёдно заменяет реплики API новым образом: сначала новая готова, потом старая останавливается.
|
||||
# Миграции выполняются один раз до замены, поэтому они должны быть совместимы с работающей версией.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
compose="docker compose --env-file .env"
|
||||
|
||||
$compose build api
|
||||
$compose run --rm migrate
|
||||
|
||||
old=$($compose ps -q api)
|
||||
count=$(echo "$old" | wc -l | tr -d ' ')
|
||||
|
||||
wait_healthy() {
|
||||
for attempt in $(seq 1 60); do
|
||||
unhealthy=0
|
||||
# переменная цикла отдельная: в sh нет локальных переменных, а $container нужен внешнему циклу
|
||||
for replica in $($compose ps -q api); do
|
||||
[ "$(docker inspect -f '{{.State.Health.Status}}' "$replica")" = healthy ] || unhealthy=1
|
||||
done
|
||||
if [ "$unhealthy" = 0 ]; then
|
||||
return 0
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
echo "новая реплика не стала healthy за 60 секунд, замена остановлена" >&2
|
||||
exit 1
|
||||
}
|
||||
|
||||
for container in $old; do
|
||||
$compose up -d --no-deps --no-recreate --no-build --scale api=$((count + 1)) api
|
||||
wait_healthy
|
||||
# балансировщику нужно две удачные проверки с периодом 1 с, с запасом
|
||||
sleep 3
|
||||
docker stop "$container"
|
||||
docker rm "$container"
|
||||
done
|
||||
echo "замена завершена, реплик: $($compose ps -q api | wc -l | tr -d ' ')"
|
||||
@@ -0,0 +1,26 @@
|
||||
-- Синтетические данные для EXPLAIN: 21 чат и 60 000 сообщений, из них 10 000 в исследуемом чате.
|
||||
-- Повторный запуск ничего не добавляет. Войти под этим пользователем нельзя: вместо hash стоит заглушка.
|
||||
|
||||
INSERT INTO users (id, username, display_name, password_hash)
|
||||
VALUES ('00000000-0000-4000-8000-000000000001', 'explain_seed', 'Данные для EXPLAIN', '!')
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO chats (id, title)
|
||||
SELECT ('00000000-0000-4000-8000-0000000001' || lpad(n::text, 2, '0'))::uuid, 'EXPLAIN чат ' || n
|
||||
FROM generate_series(0, 20) AS n
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO chat_members (chat_id, user_id, position)
|
||||
SELECT id, '00000000-0000-4000-8000-000000000001', 0 FROM chats WHERE title LIKE 'EXPLAIN чат %'
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
-- чат 00: 10 000 сообщений; чаты 01..20: по 2 500. Время идёт с шагом в секунду и перемешано между чатами.
|
||||
INSERT INTO messages (chat_id, sender_id, text, created_at)
|
||||
SELECT ('00000000-0000-4000-8000-0000000001' || lpad((CASE WHEN n % 6 = 0 THEN 0 ELSE 1 + n % 20 END)::text, 2, '0'))::uuid,
|
||||
'00000000-0000-4000-8000-000000000001',
|
||||
'сообщение ' || n,
|
||||
now() - make_interval(secs => 60000 - n)
|
||||
FROM generate_series(1, 60000) AS n
|
||||
WHERE NOT EXISTS (SELECT 1 FROM messages WHERE chat_id = '00000000-0000-4000-8000-000000000100');
|
||||
|
||||
ANALYZE messages;
|
||||
@@ -0,0 +1,82 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Проверка SIGTERM через балансировщик: начатые запросы завершаются, новые уходят на другую реплику,
|
||||
процесс выходит быстрее 10 секунд. API наружу не опубликован, поэтому незаконченные запросы открываются
|
||||
на все реплики сразу: часть из них обязательно окажется на останавливаемой."""
|
||||
import json
|
||||
import socket
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.parse
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "student-tests"))
|
||||
from api import BASE_URL, call, new_chat, new_user
|
||||
|
||||
LIMIT_SECONDS = 10
|
||||
OPEN_REQUESTS = 6
|
||||
|
||||
|
||||
def main():
|
||||
containers = subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", "ps", "-q", "api"],
|
||||
cwd=ROOT, check=True, capture_output=True, text=True,
|
||||
).stdout.split()
|
||||
target = containers[0]
|
||||
address = urllib.parse.urlsplit(BASE_URL)
|
||||
user = new_user("sigterm")
|
||||
chat = new_chat(user)
|
||||
|
||||
# заголовки и половина тела: запрос уже начат, но ещё не закончен
|
||||
body = json.dumps({"text": "сообщение, отправленное во время остановки"}).encode()
|
||||
connections = []
|
||||
for _ in range(OPEN_REQUESTS):
|
||||
head = (
|
||||
"POST /api/v1/chats/%s/messages HTTP/1.1\r\nHost: %s\r\nContent-Type: application/json\r\n"
|
||||
"Content-Length: %d\r\nAuthorization: Bearer %s\r\nIdempotency-Key: %s\r\n\r\n"
|
||||
% (chat["id"], address.netloc, len(body), user["token"], uuid.uuid4().hex)
|
||||
).encode()
|
||||
connection = socket.create_connection((address.hostname, address.port), timeout=LIMIT_SECONDS)
|
||||
connection.sendall(head + body[:10])
|
||||
connections.append(connection)
|
||||
time.sleep(0.5)
|
||||
|
||||
print("$ docker kill --signal=SIGTERM", target[:12])
|
||||
started = time.monotonic()
|
||||
subprocess.run(["docker", "kill", "--signal=SIGTERM", target], check=True, stdout=subprocess.DEVNULL)
|
||||
time.sleep(1)
|
||||
|
||||
served = [call("GET", "/health/live")[2]["X-Instance-Id"] for _ in range(20)]
|
||||
new_on_target = sum(target.startswith(instance) for instance in served)
|
||||
print("новых запросов после SIGTERM: 20, попало на останавливаемую реплику:", new_on_target)
|
||||
|
||||
finished_on_target = 0
|
||||
statuses = []
|
||||
for connection in connections:
|
||||
connection.sendall(body[10:])
|
||||
answer = connection.recv(65536).decode("utf-8", "replace")
|
||||
connection.close()
|
||||
statuses.append(answer.split("\r\n")[0])
|
||||
for line in answer.split("\r\n"):
|
||||
if line.lower().startswith("x-instance-id:") and target.startswith(line.split(":")[1].strip()):
|
||||
finished_on_target += 1
|
||||
print("начатые до SIGTERM запросы:", sorted(set(statuses)))
|
||||
print("из них завершила останавливаемая реплика:", finished_on_target)
|
||||
|
||||
exit_code = subprocess.run(["docker", "wait", target], check=True, capture_output=True, text=True).stdout.strip()
|
||||
elapsed = time.monotonic() - started
|
||||
print("процесс завершился за %.2f с, код выхода %s" % (elapsed, exit_code))
|
||||
|
||||
# контейнер, остановленный через docker kill, сам не перезапускается: поднимаем его обратно
|
||||
subprocess.run(["docker", "start", target], check=True, stdout=subprocess.DEVNULL)
|
||||
|
||||
good = all(" 201 " in status for status in statuses)
|
||||
if not good or new_on_target or not finished_on_target or elapsed > LIMIT_SECONDS or exit_code != "0":
|
||||
raise SystemExit("FAIL")
|
||||
print("PASS: остановка корректная и укладывается в %d секунд" % LIMIT_SECONDS)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+14
@@ -0,0 +1,14 @@
|
||||
#!/bin/sh
|
||||
# Останавливает реплику API, которая обслужила тест, и оставляет её остановленной.
|
||||
# Вернуть реплику: make restore
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
# X-Instance-Id равен короткому id контейнера; ищем только среди контейнеров сервиса api этого стенда
|
||||
container=$(docker compose --env-file .env ps -q api | grep "^$TARGET_INSTANCE_ID" || true)
|
||||
if [ -z "$container" ]; then
|
||||
echo "реплика $TARGET_INSTANCE_ID не найдена среди контейнеров сервиса api" >&2
|
||||
exit 3
|
||||
fi
|
||||
docker stop "$container"
|
||||
Executable
+97
@@ -0,0 +1,97 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Пик памяти реплик API при одновременных загрузках файлов около 10 MiB.
|
||||
|
||||
Перед замером реплики перезапускаются, чтобы обнулить VmHWM (пик памяти процесса). Уровни идут по
|
||||
возрастанию, поэтому VmHWM после каждого уровня показывает пик этого уровня. memory.peak контейнера
|
||||
больше: в него входит кэш страниц временных файлов, который система может освободить.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.parse
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "student-tests"))
|
||||
from api import call, new_chat, new_user
|
||||
from samples import noisy_png
|
||||
|
||||
LEVELS = (1, 10, 30)
|
||||
|
||||
|
||||
def compose(*args):
|
||||
command = ["docker", "compose", "--env-file", ".env", *args]
|
||||
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout
|
||||
|
||||
|
||||
def memory():
|
||||
result = {}
|
||||
for container in compose("ps", "-q", "api").split():
|
||||
status = subprocess.check_output(["docker", "exec", container, "cat", "/proc/1/status"], text=True)
|
||||
fields = dict(line.split(":", 1) for line in status.splitlines() if ":" in line)
|
||||
peak = subprocess.check_output(["docker", "exec", container, "cat", "/sys/fs/cgroup/memory.peak"], text=True)
|
||||
result[container[:12]] = {
|
||||
"process_peak_rss_mib": round(int(fields["VmHWM"].split()[0]) / 1024, 1),
|
||||
"cgroup_peak_mib": round(int(peak) / 1024 / 1024, 1),
|
||||
}
|
||||
return result
|
||||
|
||||
|
||||
def wait_ready():
|
||||
deadline = time.monotonic() + 60
|
||||
seen = set()
|
||||
while time.monotonic() < deadline and len(seen) < 2:
|
||||
try:
|
||||
status, _, headers = call("GET", "/health/ready", timeout=2)
|
||||
if status == 200:
|
||||
seen.add(headers["X-Instance-Id"])
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(0.2)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||||
parser.add_argument("--output")
|
||||
args = parser.parse_args()
|
||||
data = noisy_png(10 * 1024 * 1024 - 4096)
|
||||
compose("restart", "api")
|
||||
wait_ready()
|
||||
user = new_user("peak")
|
||||
chat = new_chat(user)
|
||||
path = "/api/v1/chats/%s/attachments?filename=peak.png" % urllib.parse.quote(chat["id"])
|
||||
levels = [{"parallel_uploads": 0, "memory": memory()}]
|
||||
for level in LEVELS:
|
||||
started = time.monotonic()
|
||||
|
||||
def post(_):
|
||||
sent = time.monotonic()
|
||||
status = call("POST", path, raw=data, user=user, headers={"Content-Type": "image/png"}, timeout=60)[0]
|
||||
return status, time.monotonic() - sent
|
||||
|
||||
with ThreadPoolExecutor(max_workers=level) as pool:
|
||||
results = list(pool.map(post, range(level)))
|
||||
statuses = [status for status, _ in results]
|
||||
entry = {
|
||||
"parallel_uploads": level,
|
||||
"file_bytes": len(data),
|
||||
"seconds": round(time.monotonic() - started, 2),
|
||||
"slowest_upload_s": round(max(took for _, took in results), 2),
|
||||
"statuses": {str(s): statuses.count(s) for s in sorted(set(statuses))},
|
||||
"memory": memory(),
|
||||
}
|
||||
print(json.dumps(entry, ensure_ascii=False))
|
||||
levels.append(entry)
|
||||
report = {"limit_per_replica_mib": 256, "replicas": 2, "levels": levels}
|
||||
if args.output:
|
||||
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
if any(set(level.get("statuses", {"201": 1})) != {"201"} for level in levels):
|
||||
raise SystemExit("FAIL: не все загрузки успешны")
|
||||
print("PASS: все загрузки успешны")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+12
@@ -0,0 +1,12 @@
|
||||
#!/bin/sh
|
||||
# Ждёт, пока /health/ready ответит 200, не дольше 60 секунд.
|
||||
BASE_URL=${BASE_URL:-http://localhost:8080}
|
||||
for attempt in $(seq 1 60); do
|
||||
if curl -fs -o /dev/null "$BASE_URL/health/ready"; then
|
||||
echo "готов: $BASE_URL"
|
||||
exit 0
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
echo "стенд не стал готов за 60 секунд: $BASE_URL" >&2
|
||||
exit 1
|
||||
Reference in New Issue
Block a user