ЛР 3 -- Юртаев В.А БПИ2301 -- Оценка 5 #47
+4
-11
@@ -1,13 +1,6 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
# Local synthetic test only. Copy to .env and replace the password.
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
SESSION_TTL_SECONDS=3600
|
||||
POSTGRES_PASSWORD=replace-me-with-a-local-password
|
||||
DB_POOL_SIZE=8
|
||||
|
||||
@@ -1,18 +1,14 @@
|
||||
## Лабораторная 3
|
||||
|
||||
Автор / группа: TODO
|
||||
Целевая оценка (3/4/5): TODO
|
||||
Трек 5, если заявлен: TODO
|
||||
Автор: Юртаев (группа не указана). Целевая оценка: **5**, трек 2 «Отказ узла».
|
||||
|
||||
Что реализовано и что перенесено: TODO
|
||||
Команды запуска из чистого clone: TODO
|
||||
Результаты проверок и ссылка на REPORT.md: TODO
|
||||
Ограничения / известные ошибки: TODO
|
||||
Источники и использование ИИ: TODO
|
||||
Перенесён API лабораторной 2. Добавлены общая идемпотентность сообщений в PostgreSQL, две API-реплики за HAProxy с readiness checks, отдельные миграции, hooks рестарта/отказа и трёхузловой учебный Swarm. Инструкция запуска и измерения: [REPORT.md](../REPORT.md).
|
||||
|
||||
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [ ] Контракт и публичные тесты не ослаблены.
|
||||
- [ ] make check и make test выполнены; приложен реальный вывод.
|
||||
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
|
||||
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
|
||||
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
|
||||
Проверки: `make lint check test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`, `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, `python3 tests/lb_readiness.py`, `python3 tests/level4.py`, `python3 tests/node_failover.py`, `python3 scripts/history_explain.py`. Все прошли на локальном синтетическом стенде; агрегаты сохранены в `evidence/`.
|
||||
|
||||
Ограничения: узлы Swarm — независимые Docker daemon на одном физическом Mac. PostgreSQL, его volume, manager и LB не реплицированы; их отказ стенд не переживает. HTTP доступен только на loopback для учебных данных. Секреты и токены в Git не сохраняются.
|
||||
|
||||
- [x] Обязательный API и возможности lab2 сохранены.
|
||||
- [x] Контракт и публичные тесты не ослаблены.
|
||||
- [x] Проверены рестарт, обе API-реплики, отказ worker и rolling update.
|
||||
- [x] README задания сохранён, отчёт содержит команды и ограничения.
|
||||
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
FROM python:3.12.10-slim
|
||||
WORKDIR /app
|
||||
COPY requirements.txt ./
|
||||
RUN pip install --no-cache-dir -r requirements.txt && useradd -r -u 10001 app
|
||||
COPY app ./app
|
||||
COPY migrations ./migrations
|
||||
COPY scripts/migrate.py ./scripts/migrate.py
|
||||
USER app
|
||||
EXPOSE 8080
|
||||
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--workers", "1"]
|
||||
@@ -4,7 +4,7 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
.PHONY: help check validate lint test load test-persistence test-failover
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@@ -15,6 +15,10 @@ check:
|
||||
validate:
|
||||
$(PYTHON) scripts/validate_openapi.py
|
||||
|
||||
lint:
|
||||
$(PYTHON) scripts/lint.py
|
||||
sh -n scripts/restart.sh scripts/stop-one.sh scripts/swarm-lab.sh
|
||||
|
||||
test:
|
||||
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
|
||||
@@ -1,37 +1,92 @@
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
Автор: Юртаев (группа не указана). Цель: **5, трек 2 — отказ узла**. Локальные commits `2e23dbe`, `3a3302c`; PR не создавался. Код API перенесён из лабораторной 2 и доработан с помощью Codex. Python 3.12.10, FastAPI 0.115.12, psycopg 3.2.6, Redis 5.2.1, PostgreSQL 16.8, HAProxy 3.2.6, Docker 29.3.0 (вложенные daemon 29.3.1). Изучены README, контракт и публичные тесты этого репозитория, исходники lab2, Docker Compose, Swarm CLI и [документация HAProxy по DNS discovery](https://www.haproxy.com/documentation/haproxy-configuration-tutorials/proxying-essentials/dns-resolution/).
|
||||
|
||||
## Запуск из чистого clone
|
||||
## Запуск Compose из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Проверено 23.10.2026 на Apple M4, 16 GiB RAM; Docker Desktop выделял 7.653 GiB. Достаточно Docker Engine с Compose, Python 3.9+ и свободного порта 8080. Тестовые данные синтетические, HTTP слушает только `127.0.0.1`.
|
||||
|
||||
## Архитектура и решения
|
||||
```sh
|
||||
cp .env.example .env
|
||||
# Заменить POSTGRES_PASSWORD в .env на локальный случайный пароль.
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --wait
|
||||
make lint check test
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
docker compose --env-file .env start api # восстановить остановленную реплику
|
||||
```
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
`migrate` — отдельный одноразовый сервис: он завершается до старта API. Миграции повторно запускаются без дублирования таблиц; транзакционная advisory lock защищает от случайного параллельного оператора. Для остановки без удаления данных: `docker compose --env-file .env down`. Намеренный сброс синтетических данных: `docker compose --env-file .env down -v`. `.env` и volumes исключены из Git.
|
||||
|
||||
## Доказательства критериев
|
||||
## Архитектура и корректность
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
```text
|
||||
localhost:8080 → HAProxy → API × 2 → PostgreSQL (истина: users, sessions, chats, messages, idempotency)
|
||||
↘ Redis (только необязательный кэш истории)
|
||||
```
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
API не публикует порт на хост и не хранит сессии локально. HAProxy получает адреса реплик через Docker DNS с TTL 1 с, проверяет `/health/ready` каждой и балансирует без sticky session; процесс обозначается `X-Instance-Id` (Docker hostname/container ID). В Compose DNS-имя `api` возвращает адреса контейнеров, в Swarm `tasks.lab3app_api` — адреса задач, минуя VIP. API и Redis имеют лимиты 0.75 CPU/256 MiB и 0.5 CPU/192 MiB; PostgreSQL — 1 CPU/512 MiB; LB — 0.5 CPU/128 MiB; одноразовая миграция — 0.5 CPU/256 MiB. `front` доступен LB и API, `data` — API, PostgreSQL и Redis. Пароль учебной БД задаётся в локальном `.env`; в Swarm передаётся Docker secret. Секрет не включён в образ или отчёт.
|
||||
|
||||
## Эксперименты и отказы
|
||||
Сессии, сообщения и версия истории находятся в PostgreSQL. Redis хранит только страницы с TTL 30 с. Версия чата повышается в той же транзакции, что вставляет сообщение; после COMMIT следующая реплика читает новую версию и не отдаёт старую страницу. При отказе Redis чтение идёт из PostgreSQL. `/health/live` проверяет процесс; `/health/ready` делает SQL `SELECT 1`, потому что PostgreSQL обязателен для сессий и синхронного API. PostgreSQL недоступен — 503, Redis недоступен — API остаётся готовым.
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Для сообщений обязателен `Idempotency-Key`. Первичный ключ `(user_id, chat_id, key)` в PostgreSQL сериализует параллельные запросы всех реплик. В одной транзакции фиксируются резервирование ключа, сообщение, ссылка на него и новая версия истории. Повтор с тем же текстом в течение 24 часов получает исходные `201` и Message; другой текст — 409. Истёкшую запись удаляют при следующем применении этого ключа. Проверка сессии и членства выполняется до повторного ответа. Неподтверждённый POST можно повторить с тем же ключом. Отсутствие отдельного фонового удаления истёкших ключей означает рост таблицы при большом числе одноразовых ключей; эксплуатационная очистка — следующий шаг.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
Контейнерный API healthcheck: каждые 2 с, timeout 3 с, 2 неудачи. HAProxy проверяет каждую реплику раз в 1 с, timeout проверки 1 с, исключает после 2 неудач и возвращает после 2 успехов. Настроенный максимум обнаружения живой unready реплики при обычном планировании — до 4 с (ожидание следующей проверки и две проверки до timeout); обновление адреса DNS добавляет до 1 с. Connect timeout клиентского запроса — 1 с, server/client timeout — 10 с. Uvicorn обрабатывает SIGTERM и получает 15 с на завершение запросов; readiness сбрасывается при shutdown. Отдельный тест разорвал только связь API-1 с БД, оставив процесс живым: HAProxy исключил реплику за 5.435 с **включая** 20 последовательных подтверждающих GET, затем 10 POST прошли через вторую реплику. Во время обнаружения было 2 ошибки. Это измеренный сценарий, а не универсальная жёсткая SLA при произвольной задержке планировщика/сети.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
История сортируется по `(created_at,id)` и использует keyset cursor. При неизменной истории повторов нет; новый элемент после позиции cursor может появиться на следующей странице, а вставка с более ранней позицией может быть пропущена текущим обходом. Snapshot между HTTP-запросами не обещается. Время назначает одна PostgreSQL; `clock_timestamp()` может не соответствовать порядку COMMIT и при переводе часов идти назад. UUID развязывает одинаковые отметки времени, но не превращает сортировку в порядок подтверждения транзакций. На 10 000 синтетических сообщений `EXPLAIN (ANALYZE, BUFFERS)` показал `Index Scan using messages_history_idx`, 101 прочитанная строка, 11 shared hits, 0.074 мс ([сырой план](evidence/history_explain.txt)).
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Миграция 002 добавляет таблицу и индекс, не меняя старые поля: её можно выполнить при работающей версии lab2. Однако в период смешанных lab2/lab3 API старый процесс не обеспечивает идемпотентность, поэтому клиентов с новым контрактом переключают только после завершения обновления. Swarm `update_config` заменяет по одной реплике (`start-first`, 3 с пауза), с rollback при неудаче. Проверка обновления ниже принудительно пересоздавала тот же образ; переход между разными версиями приложения не измерялся.
|
||||
|
||||
## Публичные проверки уровней 3–4
|
||||
|
||||
| Критерий | Команда | Наблюдение |
|
||||
| --- | --- | --- |
|
||||
| Контракт и линт | `make lint check` | PASS |
|
||||
| Smoke через LB | `make test` | PASS: `X-Instance-Id` в ответах, Basic/Bearer, доступ, пагинация, ключ |
|
||||
| Полный рестарт без удаления volume | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: старый токен и сообщение после рестарта API, PostgreSQL, Redis, LB |
|
||||
| Отказ API-1 | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 2 реплики до отказа; 109 записей/15 с ≈7.27 RPS, 2 ошибки, первая запись через 2.462 с |
|
||||
| Отказ API-2 после восстановления API-1 | та же команда | 111 записей/15 с ≈7.40 RPS, 1 ошибка, первая запись через 2.251 с; остановлен `api-2` |
|
||||
| Живая, но неготовая реплика | `python3 tests/lb_readiness.py` | API-1 потеряла связь с БД; исключена HAProxy за 5.435 с включая 20 подтверждений; 10 POST после исключения успешны |
|
||||
| Конкурентный ключ | `python3 tests/node_failover.py` | 16 одновременных POST через LB вернули одно Message |
|
||||
| Унаследованные проверки lab2 уровня 4 | `python3 tests/level4.py` | PASS: гонка username, rollback чата, fallback Redis, 503 при отказе PostgreSQL, expiry сессии |
|
||||
| Rolling update под нагрузкой | `scripts/swarm-lab.sh rolling-update` одновременно с `tests/load.py` | 7449 подтверждённых записей/30.035 с, 248.009 RPS, 0 ошибок; p50/p95/p99 = 12.897/37.412/73.878 мс |
|
||||
| Индекс истории lab2 | `python3 scripts/history_explain.py` | 10 000 строк, Index Scan, 11 buffer hits, 0.074 мс |
|
||||
|
||||
Скрипт `stop-one.sh` сопоставляет `TARGET_INSTANCE_ID` с Docker container ID и проверяет label сервиса `api`; он останавливает именно выбранный тестом процесс. После сценария `docker compose ps -a api` показывает остановленную реплику. При первом прогоне остановилась `api-1` (ID `d5c6218cf96c`), затем она была восстановлена; при втором — `api-2` (ID `d6788e0998bf`). `restart.sh` перезапускает все используемые сервисы без `down -v`.
|
||||
|
||||
## Трек 2: отказ узла
|
||||
|
||||
**Гипотеза:** если на двух worker работают взаимозаменяемые API, потеря одного Docker-узла оставит доступ к подтверждённым данным через оставшийся API, а Swarm разместит новую задачу API на живом worker. PostgreSQL и LB намеренно закреплены на manager: их отказ этот стенд не переживает.
|
||||
|
||||
Воспроизводимый локальный эксперимент использует три независимых Docker daemon в привилегированных контейнерах Docker-in-Docker, соединённых одной сетью. Это **логические узлы на одном физическом Mac**, поэтому не доказывает устойчивость к потере самого Mac или Docker Desktop. Swarm manager хранит PostgreSQL volume и запускает LB/Redis; два worker первоначально держат по одному API. Образ `lab3-api:local` загружается в каждый daemon; в реальных отдельных машинах нужен общий registry с закреплённым digest и защищённые сетевые каналы. Внешняя точка входа вложенного стенда — `127.0.0.1:18080`.
|
||||
|
||||
```sh
|
||||
scripts/swarm-lab.sh up
|
||||
# Дождаться ответа /health/ready; затем:
|
||||
make test BASE_URL=http://127.0.0.1:18080
|
||||
python3 tests/node_failover.py --worker lab3-worker1 --output evidence/node_failover.json
|
||||
scripts/swarm-lab.sh status
|
||||
scripts/swarm-lab.sh recover-node lab3-worker1
|
||||
# Остановка и удаление временного синтетического кластера:
|
||||
scripts/swarm-lab.sh down
|
||||
```
|
||||
|
||||
`node_failover.py` сначала создаёт чат и сессию, проверяет два разных instance ID, отправляет 16 конкурентных повторов одного ключа, затем выполняет `docker stop` worker1. До появления двух API-задач на оставшемся worker он непрерывно отправляет POST с новым ключом и после каждого успеха выполняет GET истории другим участником; неопределённый POST повторялся бы с тем же ключом. В конце проверяются все подтверждённые сообщения и отсутствие дубля. Один запуск дал:
|
||||
|
||||
| Показатель | Значение |
|
||||
| --- | ---: |
|
||||
| Размещение до / после | worker1 + worker2 / worker2 + worker2 |
|
||||
| Время появления новой задачи API | 20.311 с |
|
||||
| Успешные записи и чтения / ошибки | 92 POST + 92 GET / 0 |
|
||||
| Первая запись от начала команды остановки worker | 1.216 с (сама команда заняла 1.199 с) |
|
||||
| p50 / p95 записи | 13.096 / 16.899 мс |
|
||||
| Сохранность подтверждённых данных | подтверждена чтением через оставшийся узел |
|
||||
|
||||
Сырые агрегаты: [отказ узла](evidence/node_failover.json), [readiness](evidence/readiness_failover.json), [rolling update](evidence/swarm_rolling_load.json), [отдельная нагрузка](evidence/swarm_load.json), [снимок ресурсов во время отдельной нагрузки](evidence/swarm_stats.txt). В `node_failover.json` сохранены task ID и instance ID до и после переноса; 16 конкурентных ответов пришли от обеих исходных реплик. Во время отдельного 15-секундного прогона было 3864 успеха, 0 ошибок, 256.971 RPS. Однократный `docker stats` показал: manager 68.26% CPU / 260.3 MiB, worker1 74.43% / 150.5 MiB, worker2 79.84% / 198.8 MiB. Это расход целых вложенных узлов, включая daemon, а не только приложения.
|
||||
|
||||
Защищённая зависимость здесь — **API worker**: его задача реально исчезла с остановленного daemon и была создана на worker2; сессия и сообщения остались доступны из PostgreSQL на manager. Redis — необязательный кэш, его данные не требуются для сохранности. Единичные PostgreSQL, локальный volume manager, единственный LB и сам manager остаются SPOF. Утрата manager/его volume не выдерживается и не заявляется как защищённый сценарий. Для устойчивости к ним потребуются внешний/реплицированный PostgreSQL с проверенным failover, репликация хранения и несколько LB с переключаемой внешней точкой входа.
|
||||
|
||||
## Ограничения измерений
|
||||
|
||||
Все результаты получены на одном ноутбуке и при synthetic closed-loop нагрузке. Клиент ограничивает RPS и имеет coordinated omission; p50/p95/p99 охватывают только успешные запросы. Срез CPU/RAM один и не отражает пики. Во время отказа узла сервис продолжал отвечать за счёт второй реплики, хотя восстановление полного числа задач заняло 20 с. В Swarm не проверялись физическое отключение машины, потеря manager, отказ PostgreSQL/диска и обновление между версиями. Локальный DinD использует привилегированные контейнеры только для учебного эксперимента.
|
||||
|
||||
+500
@@ -0,0 +1,500 @@
|
||||
"""Replicated messenger API with PostgreSQL-backed sessions and idempotency."""
|
||||
|
||||
import asyncio
|
||||
import base64
|
||||
import binascii
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import socket
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import psycopg
|
||||
import redis
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from psycopg.conninfo import make_conninfo
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool, PoolTimeout
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
|
||||
DATABASE_URL = os.environ.get("DATABASE_URL", "postgresql://messenger:messenger@localhost:5432/messenger")
|
||||
database_password = os.environ.get("DATABASE_PASSWORD")
|
||||
if "DATABASE_PASSWORD_FILE" in os.environ:
|
||||
with open(os.environ["DATABASE_PASSWORD_FILE"], encoding="utf-8") as secret_file:
|
||||
database_password = secret_file.read().rstrip("\n")
|
||||
if database_password is not None:
|
||||
DATABASE_URL = make_conninfo(
|
||||
host=os.environ.get("DATABASE_HOST", "postgres"),
|
||||
dbname=os.environ.get("DATABASE_NAME", "messenger"),
|
||||
user=os.environ.get("DATABASE_USER", "messenger"),
|
||||
password=database_password,
|
||||
)
|
||||
REDIS_URL = os.environ.get("REDIS_URL", "redis://localhost:6379/0")
|
||||
SESSION_TTL = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
||||
MAX_BODY = int(os.environ.get("MAX_HTTP_BODY_BYTES", "16384"))
|
||||
POOL_SIZE = int(os.environ.get("DB_POOL_SIZE", "10"))
|
||||
CACHE_ENABLED = os.environ.get("CACHE_ENABLED", "1") == "1"
|
||||
CACHE_LOCK_ENABLED = os.environ.get("CACHE_LOCK_ENABLED", "1") == "1"
|
||||
CACHE_MISS_DELAY_MS = min(1000, max(0, int(os.environ.get("CACHE_MISS_DELAY_MS", "0"))))
|
||||
INSTANCE_ID = os.environ.get("INSTANCE_ID", "") or socket.gethostname()
|
||||
ready_for_traffic = False
|
||||
pool = ConnectionPool(DATABASE_URL, min_size=1, max_size=POOL_SIZE, timeout=3, open=False, kwargs={"row_factory": dict_row, "connect_timeout": 3, "options": "-c statement_timeout=3000 -c lock_timeout=2000"})
|
||||
cache = redis.Redis.from_url(REDIS_URL, socket_connect_timeout=0.2, socket_timeout=0.2)
|
||||
metrics = {"history_sql": 0, "history_cache_hit": 0, "history_lock_wait": 0}
|
||||
metrics_lock = threading.Lock()
|
||||
|
||||
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status, code, message, challenge=None):
|
||||
self.status, self.code, self.message, self.challenge = status, code, message, challenge
|
||||
|
||||
|
||||
def invalid(message="Некорректный запрос"):
|
||||
raise ApiError(400, "invalid_request", message)
|
||||
|
||||
|
||||
def unavailable():
|
||||
raise ApiError(503, "unavailable", "Хранилище временно недоступно")
|
||||
|
||||
|
||||
def stamp(value):
|
||||
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
|
||||
|
||||
def encode_cursor(scope, date, identifier):
|
||||
raw = json.dumps([scope, date, identifier], separators=(",", ":")).encode()
|
||||
return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
|
||||
|
||||
|
||||
def decode_cursor(scope, value):
|
||||
if value is None:
|
||||
return None
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(value + "=" * (-len(value) % 4))
|
||||
parts = json.loads(raw)
|
||||
if (not isinstance(parts, list) or len(parts) != 3 or parts[0] != scope
|
||||
or not isinstance(parts[1], str) or not isinstance(parts[2], str)):
|
||||
invalid("Некорректный cursor")
|
||||
date = datetime.fromisoformat(parts[1].replace("Z", "+00:00"))
|
||||
if date.tzinfo is None:
|
||||
invalid("Некорректный cursor")
|
||||
return date, str(uuid.UUID(parts[2]))
|
||||
except (ValueError, TypeError, binascii.Error, IndexError):
|
||||
invalid("Некорректный cursor")
|
||||
|
||||
|
||||
def identifier(value):
|
||||
try:
|
||||
result = str(uuid.UUID(value))
|
||||
if result != value.lower() or len(value) != 36:
|
||||
invalid("Некорректный UUID")
|
||||
return result
|
||||
except (ValueError, TypeError, AttributeError):
|
||||
invalid("Некорректный UUID")
|
||||
|
||||
|
||||
def text_field(value, maximum):
|
||||
if not isinstance(value, str) or not value.strip() or len(value) > maximum:
|
||||
invalid("Некорректное текстовое поле")
|
||||
return value
|
||||
|
||||
|
||||
def exact_body(value, fields):
|
||||
if not isinstance(value, dict) or set(value) != set(fields):
|
||||
invalid("Некорректные поля JSON")
|
||||
|
||||
|
||||
async def body(request, fields):
|
||||
if request.headers.get("content-type", "").split(";")[0].strip().lower() != "application/json":
|
||||
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
|
||||
declared = request.headers.get("content-length")
|
||||
if declared is not None and declared.isdecimal() and int(declared) > MAX_BODY:
|
||||
raise ApiError(413, "payload_too_large", "Тело запроса слишком велико")
|
||||
chunks = bytearray()
|
||||
async for chunk in request.stream():
|
||||
chunks.extend(chunk)
|
||||
if len(chunks) > MAX_BODY:
|
||||
raise ApiError(413, "payload_too_large", "Тело запроса слишком велико")
|
||||
try:
|
||||
value = json.loads(chunks.decode("utf-8"))
|
||||
except (UnicodeError, ValueError):
|
||||
invalid("Некорректный JSON")
|
||||
exact_body(value, fields)
|
||||
return value
|
||||
|
||||
|
||||
def user(row):
|
||||
return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"], "created_at": stamp(row["created_at"])}
|
||||
|
||||
|
||||
def message(row):
|
||||
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": row["text"], "created_at": stamp(row["created_at"])}
|
||||
|
||||
|
||||
def chat(connection, row):
|
||||
members = connection.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (row["id"],)).fetchall()
|
||||
return {"id": str(row["id"]), "title": row["title"], "member_ids": [str(item["user_id"]) for item in members], "created_at": stamp(row["created_at"])}
|
||||
|
||||
|
||||
def password_hash(password):
|
||||
salt = os.urandom(16)
|
||||
derived = hashlib.scrypt(password.encode(), salt=salt, n=16384, r=8, p=1)
|
||||
return "scrypt:16384:8:1:" + salt.hex() + ":" + derived.hex()
|
||||
|
||||
|
||||
def password_ok(password, stored):
|
||||
try:
|
||||
_, n, r, p, salt, expected = stored.split(":")
|
||||
actual = hashlib.scrypt(password.encode(), salt=bytes.fromhex(salt), n=int(n), r=int(r), p=int(p))
|
||||
return secrets.compare_digest(actual, bytes.fromhex(expected))
|
||||
except (ValueError, TypeError):
|
||||
return False
|
||||
|
||||
|
||||
def connection():
|
||||
try:
|
||||
return pool.connection()
|
||||
except psycopg.Error:
|
||||
unavailable()
|
||||
|
||||
|
||||
def actor(request):
|
||||
auth = request.headers.get("authorization", "")
|
||||
if not auth.startswith("Bearer ") or not auth[7:]:
|
||||
raise ApiError(401, "unauthorized", "Требуется сессия", 'Bearer realm="messenger"')
|
||||
digest = hashlib.sha256(auth[7:].encode()).digest()
|
||||
with connection() as db:
|
||||
row = db.execute("SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()", (digest,)).fetchone()
|
||||
if row is None:
|
||||
raise ApiError(401, "unauthorized", "Требуется сессия", 'Bearer realm="messenger"')
|
||||
return row["user_id"]
|
||||
|
||||
|
||||
def member(db, uid, cid):
|
||||
row = db.execute("SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s", (cid, uid)).fetchone()
|
||||
if row is None:
|
||||
raise ApiError(404, "not_found", "Объект не найден")
|
||||
return row
|
||||
|
||||
|
||||
def pagination(request):
|
||||
raw = request.query_params.get("limit", "50")
|
||||
if len(raw) > 20 or not re.fullmatch(r"[0-9]+", raw) or not 1 <= int(raw) <= 100:
|
||||
invalid("Некорректный limit")
|
||||
return int(raw)
|
||||
|
||||
|
||||
def bump(key):
|
||||
with metrics_lock:
|
||||
metrics[key] += 1
|
||||
|
||||
|
||||
def cache_get(key):
|
||||
try:
|
||||
raw = cache.get(key)
|
||||
if raw is not None:
|
||||
bump("history_cache_hit")
|
||||
return json.loads(raw)
|
||||
except (redis.RedisError, ValueError):
|
||||
pass
|
||||
return None
|
||||
|
||||
|
||||
def cache_set(key, data):
|
||||
try:
|
||||
cache.set(key, json.dumps(data), ex=30)
|
||||
except redis.RedisError:
|
||||
pass
|
||||
|
||||
|
||||
def history(db, cid, limit, cursor, version):
|
||||
key = f"history:{cid}:{version}:{limit}:{cursor or '-'}"
|
||||
hit = cache_get(key) if CACHE_ENABLED else None
|
||||
if hit is not None:
|
||||
return hit
|
||||
lock_key = "lock:" + key
|
||||
token = secrets.token_hex(16)
|
||||
locked = False
|
||||
if CACHE_ENABLED and CACHE_LOCK_ENABLED:
|
||||
try:
|
||||
locked = bool(cache.set(lock_key, token, nx=True, px=2000))
|
||||
if not locked:
|
||||
bump("history_lock_wait")
|
||||
for _ in range(20):
|
||||
time.sleep(0.025)
|
||||
hit = cache_get(key)
|
||||
if hit is not None:
|
||||
return hit
|
||||
locked = bool(cache.set(lock_key, token, nx=True, px=2000))
|
||||
except redis.RedisError:
|
||||
pass
|
||||
if CACHE_MISS_DELAY_MS:
|
||||
time.sleep(CACHE_MISS_DELAY_MS / 1000)
|
||||
if cursor is None:
|
||||
rows = db.execute("SELECT * FROM messages WHERE chat_id=%s ORDER BY created_at,id LIMIT %s", (cid, limit + 1)).fetchall()
|
||||
else:
|
||||
rows = db.execute("SELECT * FROM messages WHERE chat_id=%s AND (created_at,id)>(%s,%s) ORDER BY created_at,id LIMIT %s", (cid, cursor[0], cursor[1], limit + 1)).fetchall()
|
||||
bump("history_sql")
|
||||
result = {"items": [message(row) for row in rows[:limit]], "next_cursor": None}
|
||||
if len(rows) > limit:
|
||||
last = rows[limit - 1]
|
||||
result["next_cursor"] = encode_cursor(str(cid), stamp(last["created_at"]), str(last["id"]))
|
||||
if CACHE_ENABLED:
|
||||
cache_set(key, result)
|
||||
if locked:
|
||||
try:
|
||||
cache.eval("if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) end", 1, lock_key, token)
|
||||
except redis.RedisError:
|
||||
pass
|
||||
return result
|
||||
|
||||
|
||||
def migrate():
|
||||
from pathlib import Path
|
||||
files = sorted(Path(__file__).resolve().parent.parent.joinpath("migrations").glob("*.sql"))
|
||||
with pool.connection() as db:
|
||||
with db.transaction():
|
||||
db.execute("SELECT pg_advisory_xact_lock(2172002)")
|
||||
db.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY)")
|
||||
for file in files:
|
||||
if db.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (file.name,)).fetchone() is None:
|
||||
db.execute(file.read_text())
|
||||
db.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (file.name,))
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_app):
|
||||
global ready_for_traffic
|
||||
pool.open()
|
||||
pool.wait(timeout=20)
|
||||
ready_for_traffic = True
|
||||
yield
|
||||
ready_for_traffic = False
|
||||
pool.close()
|
||||
|
||||
|
||||
app = FastAPI(lifespan=lifespan)
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_error(request, error):
|
||||
request_id = request.state.request_id
|
||||
code = "not_found" if error.status_code == 404 else "invalid_request"
|
||||
return JSONResponse({"error": {"code": code, "message": "Объект не найден" if error.status_code == 404 else "Некорректный запрос", "request_id": request_id}}, status_code=error.status_code)
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def envelope(request, call_next):
|
||||
request_id = str(uuid.uuid4())
|
||||
request.state.request_id = request_id
|
||||
try:
|
||||
response = await call_next(request)
|
||||
except ApiError as exc:
|
||||
response = JSONResponse({"error": {"code": exc.code, "message": exc.message, "request_id": request_id}}, status_code=exc.status)
|
||||
if exc.challenge:
|
||||
response.headers["WWW-Authenticate"] = exc.challenge
|
||||
except (psycopg.OperationalError, psycopg.InterfaceError, psycopg.errors.QueryCanceled,
|
||||
psycopg.errors.LockNotAvailable, PoolTimeout):
|
||||
response = JSONResponse({"error": {"code": "unavailable", "message": "Хранилище временно недоступно", "request_id": request_id}}, status_code=503)
|
||||
except Exception:
|
||||
response = JSONResponse({"error": {"code": "internal_error", "message": "Внутренняя ошибка", "request_id": request_id}}, status_code=500)
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
response.headers["X-Instance-Id"] = INSTANCE_ID
|
||||
return response
|
||||
|
||||
|
||||
@app.get("/health/live")
|
||||
def live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
def ready():
|
||||
if not ready_for_traffic:
|
||||
unavailable()
|
||||
with connection() as db:
|
||||
db.execute("SELECT 1")
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
async def create_user(request: Request):
|
||||
data = await body(request, ("username", "display_name", "password"))
|
||||
name = data["username"]
|
||||
if not isinstance(name, str) or not re.fullmatch(r"[a-z0-9_]{3,32}", name):
|
||||
invalid("Некорректный username")
|
||||
display = text_field(data["display_name"], 100)
|
||||
password = data["password"]
|
||||
if not isinstance(password, str) or not password.strip() or not 12 <= len(password) <= 128:
|
||||
invalid("Некорректный пароль")
|
||||
try:
|
||||
return await asyncio.to_thread(insert_user, name, display, password)
|
||||
except psycopg.errors.UniqueViolation:
|
||||
raise ApiError(409, "conflict", "Username уже занят") from None
|
||||
|
||||
|
||||
def insert_user(name, display, password):
|
||||
digest = password_hash(password)
|
||||
with connection() as db:
|
||||
row = db.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING *", (uuid.uuid4(), name, display, digest)).fetchone()
|
||||
return user(row)
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
async def login(request: Request):
|
||||
async for chunk in request.stream():
|
||||
if chunk:
|
||||
invalid("Тело запроса не допускается")
|
||||
auth = request.headers.get("authorization", "")
|
||||
try:
|
||||
if not auth.startswith("Basic "):
|
||||
raise ValueError()
|
||||
decoded = base64.b64decode(auth[6:], validate=True).decode("utf-8")
|
||||
name, password = decoded.split(":", 1)
|
||||
except (ValueError, UnicodeError, binascii.Error):
|
||||
raise ApiError(401, "unauthorized", "Неверные учётные данные", 'Basic realm="messenger", charset="UTF-8"') from None
|
||||
return await asyncio.to_thread(create_session, name, password)
|
||||
|
||||
|
||||
def create_session(name, password):
|
||||
with connection() as db:
|
||||
row = db.execute("SELECT * FROM users WHERE username=%s", (name,)).fetchone()
|
||||
if row is None or not password_ok(password, row["password_hash"]):
|
||||
raise ApiError(401, "unauthorized", "Неверные учётные данные", 'Basic realm="messenger", charset="UTF-8"')
|
||||
token = secrets.token_urlsafe(32)
|
||||
expiry = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)
|
||||
db.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,%s)", (hashlib.sha256(token.encode()).digest(), row["id"], expiry))
|
||||
return {"token": token, "token_type": "Bearer", "expires_at": stamp(expiry), "user": user(row)}
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
def logout(request: Request):
|
||||
actor(request)
|
||||
token = request.headers["authorization"][7:]
|
||||
with connection() as db:
|
||||
db.execute("DELETE FROM sessions WHERE token_hash=%s", (hashlib.sha256(token.encode()).digest(),))
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
def me(request: Request):
|
||||
uid = actor(request)
|
||||
with connection() as db:
|
||||
row = db.execute("SELECT * FROM users WHERE id=%s", (uid,)).fetchone()
|
||||
return user(row)
|
||||
|
||||
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
async def create_chat(request: Request):
|
||||
uid = actor(request)
|
||||
data = await body(request, ("title", "member_ids"))
|
||||
title = text_field(data["title"], 100)
|
||||
raw = data["member_ids"]
|
||||
if not isinstance(raw, list) or not 1 <= len(raw) <= 100:
|
||||
invalid("Некорректный список участников")
|
||||
members = [identifier(item) for item in raw]
|
||||
if len(set(members)) != len(members) or str(uid) not in members:
|
||||
invalid("Некорректный список участников")
|
||||
return await asyncio.to_thread(insert_chat, uid, title, members)
|
||||
|
||||
|
||||
def insert_chat(uid, title, members):
|
||||
with connection() as db:
|
||||
with db.transaction():
|
||||
count = db.execute("SELECT count(*) AS n FROM users WHERE id = ANY(%s::uuid[])", (members,)).fetchone()["n"]
|
||||
if count != len(members):
|
||||
invalid("Неизвестный участник")
|
||||
row = db.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING *", (uuid.uuid4(), title)).fetchone()
|
||||
for member_id in members:
|
||||
db.execute("INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)", (row["id"], member_id))
|
||||
db.execute("INSERT INTO chat_versions(chat_id) VALUES (%s)", (row["id"],))
|
||||
return chat(db, row)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats")
|
||||
def list_chats(request: Request):
|
||||
uid = actor(request)
|
||||
limit = pagination(request)
|
||||
cursor = decode_cursor("chats:" + str(uid), request.query_params.get("cursor"))
|
||||
with connection() as db:
|
||||
if cursor is None:
|
||||
rows = db.execute("SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s ORDER BY c.created_at,c.id LIMIT %s", (uid, limit + 1)).fetchall()
|
||||
else:
|
||||
valid = db.execute("SELECT 1 FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s AND c.created_at=%s AND c.id=%s", (uid, cursor[0], cursor[1])).fetchone()
|
||||
if valid is None:
|
||||
invalid("Некорректный cursor")
|
||||
rows = db.execute("SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s AND (c.created_at,c.id)>(%s,%s) ORDER BY c.created_at,c.id LIMIT %s", (uid, cursor[0], cursor[1], limit + 1)).fetchall()
|
||||
items = [chat(db, row) for row in rows[:limit]]
|
||||
next_cursor = encode_cursor("chats:" + str(uid), stamp(rows[limit - 1]["created_at"]), str(rows[limit - 1]["id"])) if len(rows) > limit else None
|
||||
return {"items": items, "next_cursor": next_cursor}
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
def get_chat(chat_id: str, request: Request):
|
||||
uid = actor(request)
|
||||
cid = identifier(chat_id)
|
||||
with connection() as db:
|
||||
return chat(db, member(db, uid, cid))
|
||||
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
async def create_message(chat_id: str, request: Request):
|
||||
uid = actor(request)
|
||||
cid = identifier(chat_id)
|
||||
key = request.headers.get("idempotency-key", "")
|
||||
if not re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", key, flags=re.ASCII):
|
||||
invalid("Некорректный Idempotency-Key")
|
||||
data = await body(request, ("text",))
|
||||
content = text_field(data["text"], 4000)
|
||||
return await asyncio.to_thread(insert_message, uid, cid, content, key)
|
||||
|
||||
|
||||
def insert_message(uid, cid, content, key):
|
||||
with connection() as db:
|
||||
with db.transaction():
|
||||
member(db, uid, cid)
|
||||
# The unique constraint serializes concurrent requests on any replica.
|
||||
db.execute("DELETE FROM message_idempotency WHERE user_id=%s AND chat_id=%s AND key=%s AND expires_at<=clock_timestamp()", (uid, cid, key))
|
||||
claimed = db.execute("INSERT INTO message_idempotency(user_id,chat_id,key,body_hash,expires_at) VALUES (%s,%s,%s,%s,clock_timestamp()+interval '24 hours') ON CONFLICT DO NOTHING RETURNING key", (uid, cid, key, hashlib.sha256(json.dumps({"text": content}, ensure_ascii=False, sort_keys=True).encode()).digest())).fetchone()
|
||||
if claimed is None:
|
||||
previous = db.execute("SELECT body_hash,message_id FROM message_idempotency WHERE user_id=%s AND chat_id=%s AND key=%s", (uid, cid, key)).fetchone()
|
||||
expected = hashlib.sha256(json.dumps({"text": content}, ensure_ascii=False, sort_keys=True).encode()).digest()
|
||||
if previous is None or previous["body_hash"] != expected:
|
||||
raise ApiError(409, "conflict", "Ключ уже использован для другого сообщения")
|
||||
return message(db.execute("SELECT * FROM messages WHERE id=%s", (previous["message_id"],)).fetchone())
|
||||
row = db.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *", (uuid.uuid4(), cid, uid, content)).fetchone()
|
||||
db.execute("UPDATE message_idempotency SET message_id=%s WHERE user_id=%s AND chat_id=%s AND key=%s", (row["id"], uid, cid, key))
|
||||
db.execute("UPDATE chat_versions SET version=version+1 WHERE chat_id=%s", (cid,))
|
||||
return message(row)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
def list_messages(chat_id: str, request: Request):
|
||||
uid = actor(request)
|
||||
cid = identifier(chat_id)
|
||||
limit = pagination(request)
|
||||
cursor = decode_cursor(cid, request.query_params.get("cursor"))
|
||||
with connection() as db:
|
||||
member(db, uid, cid)
|
||||
if cursor is not None:
|
||||
valid = db.execute("SELECT 1 FROM messages WHERE chat_id=%s AND created_at=%s AND id=%s", (cid, cursor[0], cursor[1])).fetchone()
|
||||
if valid is None:
|
||||
invalid("Некорректный cursor")
|
||||
version = db.execute("SELECT version FROM chat_versions WHERE chat_id=%s", (cid,)).fetchone()["version"]
|
||||
return history(db, cid, limit, cursor, version)
|
||||
|
||||
|
||||
@app.get("/internal/cache-metrics")
|
||||
def cache_metrics(request: Request):
|
||||
if not os.environ.get("ENABLE_EXPERIMENT_METRICS") or request.client.host not in ("127.0.0.1", "::1"):
|
||||
raise ApiError(404, "not_found", "Объект не найден")
|
||||
with metrics_lock:
|
||||
return dict(metrics)
|
||||
+112
@@ -0,0 +1,112 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.8-alpine
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
networks: [data]
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 3s
|
||||
timeout: 2s
|
||||
retries: 20
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
|
||||
redis:
|
||||
image: redis:7.4.2-alpine
|
||||
command: ["redis-server", "--save", "", "--appendonly", "no", "--maxmemory", "128mb", "--maxmemory-policy", "allkeys-lru"]
|
||||
networks: [data]
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 3s
|
||||
timeout: 2s
|
||||
retries: 20
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 192M
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
command: ["python", "-m", "scripts.migrate"]
|
||||
environment: &database_env
|
||||
DATABASE_HOST: postgres
|
||||
DATABASE_NAME: messenger
|
||||
DATABASE_USER: messenger
|
||||
DATABASE_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
|
||||
networks: [data]
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 256M
|
||||
|
||||
api:
|
||||
build: .
|
||||
environment:
|
||||
<<: *database_env
|
||||
REDIS_URL: redis://redis:6379/0
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
DB_POOL_SIZE: ${DB_POOL_SIZE:-8}
|
||||
networks: [front, data]
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
redis:
|
||||
condition: service_healthy
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 15s
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).close()"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
start_period: 5s
|
||||
retries: 2
|
||||
deploy:
|
||||
replicas: ${API_REPLICAS:-2}
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.75"
|
||||
memory: 256M
|
||||
|
||||
lb:
|
||||
image: haproxy:3.2.6-alpine
|
||||
volumes:
|
||||
- ./infra/haproxy-compose.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
|
||||
networks: [front]
|
||||
ports:
|
||||
- "127.0.0.1:${APP_PORT:-8080}:8080"
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_healthy
|
||||
restart: unless-stopped
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/health/ready"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 3
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
|
||||
networks:
|
||||
front:
|
||||
data:
|
||||
internal: true
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
+7
-2
@@ -1,5 +1,10 @@
|
||||
# Доказательства
|
||||
|
||||
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
|
||||
- `node_failover.json` — остановка Docker daemon worker1, перенос API на worker2, конкурентный Idempotency-Key, чтение и запись.
|
||||
- `swarm_rolling_load.json` — 30 секунд записи во время `scripts/swarm-lab.sh rolling-update`.
|
||||
- `swarm_rolling_update.txt` — завершение поочерёдного обновления сервиса.
|
||||
- `swarm_load.json` и `swarm_stats.txt` — отдельная 15-секундная нагрузка и срез CPU/RAM узлов.
|
||||
- `readiness_failover.json` — исключение живой, но неготовой API-реплики активной проверкой HAProxy.
|
||||
- `history_explain.txt` — план индексного чтения истории на 10 000 синтетических сообщениях.
|
||||
|
||||
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
|
||||
Это агрегированные результаты синтетического локального эксперимента. Токены и пароль БД здесь не сохраняются. Команды, ограничения и выводы приведены в [REPORT.md](../REPORT.md).
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
synthetic_chat_id=493ca34c-b101-414a-a747-56017577daf0
|
||||
message_count=10000
|
||||
Limit (cost=0.29..10.73 rows=101 width=69) (actual time=0.015..0.042 rows=101 loops=1)
|
||||
Buffers: shared hit=11
|
||||
-> Index Scan using messages_history_idx on messages (cost=0.29..1034.81 rows=10000 width=69) (actual time=0.014..0.034 rows=101 loops=1)
|
||||
Index Cond: (chat_id = '493ca34c-b101-414a-a747-56017577daf0'::uuid)
|
||||
Buffers: shared hit=11
|
||||
Planning:
|
||||
Buffers: shared hit=109
|
||||
Planning Time: 0.406 ms
|
||||
Execution Time: 0.074 ms
|
||||
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"before_tasks": [
|
||||
{
|
||||
"task_id": "5qmzptzqohbf",
|
||||
"node": "lab3-worker2"
|
||||
},
|
||||
{
|
||||
"task_id": "iypq8msbdy1k",
|
||||
"node": "lab3-worker1"
|
||||
}
|
||||
],
|
||||
"after_tasks": [
|
||||
{
|
||||
"task_id": "5qmzptzqohbf",
|
||||
"node": "lab3-worker2"
|
||||
},
|
||||
{
|
||||
"task_id": "w19aa9l23olu",
|
||||
"node": "lab3-worker2"
|
||||
}
|
||||
],
|
||||
"before_instance_ids": [
|
||||
"63f148667462",
|
||||
"8b2a7bca0580"
|
||||
],
|
||||
"after_instance_ids": [
|
||||
"63f148667462",
|
||||
"eb4b7f490edb"
|
||||
],
|
||||
"concurrent_replays": 16,
|
||||
"concurrent_message_count": 1,
|
||||
"concurrent_instance_ids": [
|
||||
"63f148667462",
|
||||
"8b2a7bca0580"
|
||||
],
|
||||
"successful_writes": 92,
|
||||
"successful_reads": 92,
|
||||
"failed_post_attempts": 0,
|
||||
"failed_read_attempts": 0,
|
||||
"docker_stop_seconds": 1.199,
|
||||
"first_success_seconds": 1.216,
|
||||
"replacement_running_seconds": 20.311,
|
||||
"confirmed_messages_preserved": true,
|
||||
"latency_p50_ms": 13.096,
|
||||
"latency_p95_ms": 16.899
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
{
|
||||
"target_instance_id": "d5c6218cf96c",
|
||||
"observed_before": [
|
||||
"d5c6218cf96c",
|
||||
"d6788e0998bf"
|
||||
],
|
||||
"excluded_within_seconds": 5.435,
|
||||
"transient_errors": 2,
|
||||
"successful_writes_after_exclusion": 10
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.037,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 3864,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 256.971,
|
||||
"successful_latency_ms": {
|
||||
"p50": 13.08,
|
||||
"p95": 31.988,
|
||||
"p99": 60.431
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 30.0,
|
||||
"elapsed_seconds": 30.035,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 7449,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 248.009,
|
||||
"successful_latency_ms": {
|
||||
"p50": 12.897,
|
||||
"p95": 37.412,
|
||||
"p99": 73.878
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
lab3app_api
|
||||
overall progress: 0 out of 2 tasks
|
||||
1/2:
|
||||
2/2:
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 0 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 1 out of 2 tasks
|
||||
overall progress: 2 out of 2 tasks
|
||||
verify: Waiting 5 seconds to verify that tasks are stable...
|
||||
verify: Waiting 5 seconds to verify that tasks are stable...
|
||||
verify: Waiting 5 seconds to verify that tasks are stable...
|
||||
verify: Waiting 5 seconds to verify that tasks are stable...
|
||||
verify: Waiting 5 seconds to verify that tasks are stable...
|
||||
verify: Waiting 4 seconds to verify that tasks are stable...
|
||||
verify: Waiting 4 seconds to verify that tasks are stable...
|
||||
verify: Waiting 4 seconds to verify that tasks are stable...
|
||||
verify: Waiting 4 seconds to verify that tasks are stable...
|
||||
verify: Waiting 4 seconds to verify that tasks are stable...
|
||||
verify: Waiting 3 seconds to verify that tasks are stable...
|
||||
verify: Waiting 3 seconds to verify that tasks are stable...
|
||||
verify: Waiting 3 seconds to verify that tasks are stable...
|
||||
verify: Waiting 3 seconds to verify that tasks are stable...
|
||||
verify: Waiting 3 seconds to verify that tasks are stable...
|
||||
verify: Waiting 2 seconds to verify that tasks are stable...
|
||||
verify: Waiting 2 seconds to verify that tasks are stable...
|
||||
verify: Waiting 2 seconds to verify that tasks are stable...
|
||||
verify: Waiting 2 seconds to verify that tasks are stable...
|
||||
verify: Waiting 2 seconds to verify that tasks are stable...
|
||||
verify: Waiting 1 seconds to verify that tasks are stable...
|
||||
verify: Waiting 1 seconds to verify that tasks are stable...
|
||||
verify: Waiting 1 seconds to verify that tasks are stable...
|
||||
verify: Waiting 1 seconds to verify that tasks are stable...
|
||||
verify: Waiting 1 seconds to verify that tasks are stable...
|
||||
verify: Service lab3app_api converged
|
||||
@@ -0,0 +1,3 @@
|
||||
lab3-manager 68.26% 260.3MiB / 7.653GiB
|
||||
lab3-worker1 74.43% 150.5MiB / 7.653GiB
|
||||
lab3-worker2 79.84% 198.8MiB / 7.653GiB
|
||||
+4
-4
@@ -1,7 +1,7 @@
|
||||
# Инфраструктура студента
|
||||
# Инфраструктура
|
||||
|
||||
Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли.
|
||||
`compose.yaml` — основной локальный стенд: HAProxy (`haproxy-compose.cfg`), две API-реплики, отдельный `migrate`, PostgreSQL и Redis. Запуск: `docker compose --env-file .env up -d --build --wait`. `haproxy-swarm.cfg` проверяет адреса задач Swarm через DNS и `/health/ready`.
|
||||
|
||||
В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд.
|
||||
`swarm-data.yaml` и `swarm-app.yaml` используются скриптом `scripts/swarm-lab.sh` для трёх логических узлов. Скрипт сначала поднимает хранилища, затем однократно применяет миграции и запускает API/LB. PostgreSQL закреплён на manager, API — на worker. Остановка одного worker проверяется `tests/node_failover.py`.
|
||||
|
||||
Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику.
|
||||
Версии, лимиты, health/readiness, секреты, доказательства и ограничения описаны в [REPORT.md](../REPORT.md). `compose.example.yaml` остаётся шаблоном задания.
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
global
|
||||
maxconn 2048
|
||||
|
||||
defaults
|
||||
mode http
|
||||
timeout connect 1s
|
||||
timeout client 10s
|
||||
timeout server 10s
|
||||
timeout check 1s
|
||||
|
||||
resolvers docker
|
||||
nameserver dns1 127.0.0.11:53
|
||||
accepted_payload_size 8192
|
||||
hold valid 1s
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
|
||||
frontend public
|
||||
bind :8080
|
||||
default_backend api
|
||||
|
||||
backend api
|
||||
balance roundrobin
|
||||
option httpchk GET /health/ready
|
||||
http-check expect status 200
|
||||
default-server inter 1s fall 2 rise 2
|
||||
server-template replica 2 api:8080 check resolvers docker init-addr none
|
||||
@@ -0,0 +1,27 @@
|
||||
global
|
||||
maxconn 2048
|
||||
|
||||
defaults
|
||||
mode http
|
||||
timeout connect 1s
|
||||
timeout client 10s
|
||||
timeout server 10s
|
||||
timeout check 1s
|
||||
|
||||
resolvers docker
|
||||
nameserver dns1 127.0.0.11:53
|
||||
accepted_payload_size 8192
|
||||
hold valid 1s
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
|
||||
frontend public
|
||||
bind :8080
|
||||
default_backend api
|
||||
|
||||
backend api
|
||||
balance roundrobin
|
||||
option httpchk GET /health/ready
|
||||
http-check expect status 200
|
||||
default-server inter 1s fall 2 rise 2
|
||||
server-template replica 2 tasks.lab3app_api:8080 check resolvers docker init-addr none
|
||||
@@ -0,0 +1,68 @@
|
||||
version: "3.8"
|
||||
services:
|
||||
api:
|
||||
image: lab3-api:local
|
||||
environment:
|
||||
DATABASE_HOST: lab3data_postgres
|
||||
DATABASE_NAME: messenger
|
||||
DATABASE_USER: messenger
|
||||
DATABASE_PASSWORD_FILE: /run/secrets/lab3_db_password
|
||||
REDIS_URL: redis://lab3data_redis:6379/0
|
||||
SESSION_TTL_SECONDS: "3600"
|
||||
DB_POOL_SIZE: "8"
|
||||
secrets: [lab3_db_password]
|
||||
networks: [data]
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).close()"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 2
|
||||
deploy:
|
||||
replicas: 2
|
||||
placement:
|
||||
constraints: [node.labels.lab3_compute == true]
|
||||
preferences:
|
||||
- spread: node.hostname
|
||||
update_config:
|
||||
parallelism: 1
|
||||
delay: 3s
|
||||
order: start-first
|
||||
failure_action: rollback
|
||||
rollback_config:
|
||||
parallelism: 1
|
||||
order: start-first
|
||||
restart_policy:
|
||||
condition: on-failure
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.75"
|
||||
memory: 256M
|
||||
lb:
|
||||
image: haproxy:3.2.6-alpine
|
||||
configs:
|
||||
- source: lab3_haproxy_conf
|
||||
target: /usr/local/etc/haproxy/haproxy.cfg
|
||||
networks: [data]
|
||||
ports:
|
||||
- target: 8080
|
||||
published: 8080
|
||||
protocol: tcp
|
||||
mode: host
|
||||
deploy:
|
||||
replicas: 1
|
||||
placement:
|
||||
constraints: [node.labels.lab3_storage == true]
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 128M
|
||||
networks:
|
||||
data:
|
||||
external: true
|
||||
name: lab3data_data
|
||||
secrets:
|
||||
lab3_db_password:
|
||||
external: true
|
||||
configs:
|
||||
lab3_haproxy_conf:
|
||||
external: true
|
||||
@@ -0,0 +1,41 @@
|
||||
version: "3.8"
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.8-alpine
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/lab3_db_password
|
||||
secrets: [lab3_db_password]
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
networks: [data]
|
||||
deploy:
|
||||
replicas: 1
|
||||
placement:
|
||||
constraints: [node.labels.lab3_storage == true]
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
redis:
|
||||
image: redis:7.4.2-alpine
|
||||
command: ["redis-server", "--save", "", "--appendonly", "no", "--maxmemory", "128mb", "--maxmemory-policy", "allkeys-lru"]
|
||||
networks: [data]
|
||||
deploy:
|
||||
replicas: 1
|
||||
placement:
|
||||
constraints: [node.labels.lab3_storage == true]
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 192M
|
||||
networks:
|
||||
data:
|
||||
driver: overlay
|
||||
attachable: true
|
||||
volumes:
|
||||
postgres_data:
|
||||
secrets:
|
||||
lab3_db_password:
|
||||
external: true
|
||||
@@ -0,0 +1,38 @@
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username varchar(32) NOT NULL UNIQUE,
|
||||
display_name varchar(100) NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
CONSTRAINT username_format CHECK (username ~ '^[a-z0-9_]{3,32}$')
|
||||
);
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title varchar(100) NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
CREATE INDEX chats_order_idx ON chats (created_at, id);
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
sender_id uuid NOT NULL REFERENCES users(id),
|
||||
text varchar(4000) NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
CREATE TABLE chat_versions (
|
||||
chat_id uuid PRIMARY KEY REFERENCES chats(id),
|
||||
version bigint NOT NULL DEFAULT 0
|
||||
);
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
expires_at timestamptz NOT NULL
|
||||
);
|
||||
CREATE INDEX sessions_expiry_idx ON sessions (expires_at);
|
||||
@@ -0,0 +1,10 @@
|
||||
CREATE TABLE message_idempotency (
|
||||
user_id uuid NOT NULL REFERENCES users(id),
|
||||
chat_id uuid NOT NULL REFERENCES chats(id),
|
||||
key varchar(128) NOT NULL,
|
||||
body_hash bytea NOT NULL,
|
||||
message_id uuid UNIQUE REFERENCES messages(id),
|
||||
expires_at timestamptz NOT NULL,
|
||||
PRIMARY KEY (user_id, chat_id, key)
|
||||
);
|
||||
CREATE INDEX message_idempotency_expiry_idx ON message_idempotency (expires_at);
|
||||
@@ -0,0 +1,4 @@
|
||||
fastapi==0.115.12
|
||||
uvicorn==0.34.2
|
||||
psycopg[binary,pool]==3.2.6
|
||||
redis==5.2.1
|
||||
@@ -0,0 +1,50 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Seed 10k synthetic messages and save the indexed history query plan."""
|
||||
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import uuid
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def psql(sql):
|
||||
command = ["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres",
|
||||
"psql", "-U", "messenger", "-d", "messenger", "-X", "-q", "-t", "-A",
|
||||
"-v", "ON_ERROR_STOP=1", "-c", sql]
|
||||
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout.strip()
|
||||
|
||||
|
||||
def main():
|
||||
owner = psql("SELECT id FROM users ORDER BY created_at LIMIT 1")
|
||||
if not owner:
|
||||
raise SystemExit("Run make test first to create a synthetic user")
|
||||
owner = str(uuid.UUID(owner))
|
||||
chat = str(uuid.uuid4())
|
||||
psql(f"""
|
||||
BEGIN;
|
||||
INSERT INTO chats(id,title) VALUES ('{chat}', 'History index probe');
|
||||
INSERT INTO chat_members(chat_id,user_id) VALUES ('{chat}', '{owner}');
|
||||
INSERT INTO chat_versions(chat_id) VALUES ('{chat}');
|
||||
INSERT INTO messages(id,chat_id,sender_id,text,created_at)
|
||||
SELECT gen_random_uuid(), '{chat}', '{owner}', 'probe-' || g,
|
||||
clock_timestamp() + g * interval '1 microsecond'
|
||||
FROM generate_series(1,10000) AS g;
|
||||
COMMIT;
|
||||
ANALYZE messages;
|
||||
""")
|
||||
count = psql(f"SELECT count(*) FROM messages WHERE chat_id='{chat}'")
|
||||
assert count == "10000", count
|
||||
plan = psql(f"""
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id,chat_id,sender_id,text,created_at FROM messages
|
||||
WHERE chat_id='{chat}' ORDER BY created_at,id LIMIT 101;
|
||||
""")
|
||||
result = f"synthetic_chat_id={chat}\nmessage_count={count}\n{plan}\n"
|
||||
(ROOT / "evidence/history_explain.txt").write_text(result)
|
||||
print(result)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,49 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Offline lint for this small Python project: syntax, whitespace, unused imports."""
|
||||
|
||||
import ast
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
FILES = [ROOT / "app/main.py", ROOT / "scripts/migrate.py", ROOT / "scripts/history_explain.py", ROOT / "scripts/lint.py", ROOT / "tests/node_failover.py", ROOT / "tests/level4.py", ROOT / "tests/lb_readiness.py"]
|
||||
|
||||
|
||||
def check(path):
|
||||
source = path.read_text()
|
||||
issues = []
|
||||
try:
|
||||
tree = ast.parse(source, filename=str(path))
|
||||
except SyntaxError as error:
|
||||
return [f"{path}:{error.lineno}: {error.msg}"]
|
||||
used = {node.id for node in ast.walk(tree) if isinstance(node, ast.Name)}
|
||||
for node in ast.walk(tree):
|
||||
if isinstance(node, ast.Import):
|
||||
imports = [(item.asname or item.name.split(".")[0], node.lineno) for item in node.names]
|
||||
elif isinstance(node, ast.ImportFrom):
|
||||
imports = [(item.asname or item.name, node.lineno) for item in node.names]
|
||||
else:
|
||||
continue
|
||||
for name, line in imports:
|
||||
if name not in used:
|
||||
issues.append(f"{path}:{line}: unused import {name}")
|
||||
for number, line in enumerate(source.splitlines(), 1):
|
||||
if line.rstrip() != line:
|
||||
issues.append(f"{path}:{number}: trailing whitespace")
|
||||
if "\t" in line:
|
||||
issues.append(f"{path}:{number}: tab character")
|
||||
return issues
|
||||
|
||||
|
||||
def main():
|
||||
issues = [issue for path in FILES for issue in check(path)]
|
||||
if issues:
|
||||
print("\n".join(issues))
|
||||
return 1
|
||||
print(f"PASS: lint ({len(FILES)} Python files)")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,16 @@
|
||||
"""Run schema changes once before starting API replicas."""
|
||||
|
||||
from app.main import migrate, pool
|
||||
|
||||
|
||||
def main():
|
||||
pool.open()
|
||||
try:
|
||||
pool.wait(timeout=20)
|
||||
migrate()
|
||||
finally:
|
||||
pool.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+4
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres redis api lb >/dev/null
|
||||
Executable
+12
@@ -0,0 +1,12 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}"
|
||||
case "$TARGET_INSTANCE_ID" in
|
||||
*[!a-fA-F0-9]*|'') echo "Invalid instance id" >&2; exit 2 ;;
|
||||
esac
|
||||
service=$(docker inspect --format '{{ index .Config.Labels "com.docker.compose.service" }}' "$TARGET_INSTANCE_ID")
|
||||
if [ "$service" != api ]; then
|
||||
echo "Target is not a Compose API replica" >&2
|
||||
exit 2
|
||||
fi
|
||||
docker stop -t 1 "$TARGET_INSTANCE_ID" >/dev/null
|
||||
Executable
+78
@@ -0,0 +1,78 @@
|
||||
#!/bin/sh
|
||||
# Local three-daemon Swarm for the node-loss experiment. All data are synthetic.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
manager() { docker exec lab3-manager docker "$@"; }
|
||||
|
||||
case "${1:-}" in
|
||||
up)
|
||||
test -f .env || { echo "Create .env first" >&2; exit 2; }
|
||||
docker network create lab3-nodes >/dev/null
|
||||
docker run -d --privileged --network lab3-nodes --name lab3-manager --hostname lab3-manager -p 127.0.0.1:18080:8080 docker:29.3-dind --host=unix:///var/run/docker.sock >/dev/null
|
||||
for node in lab3-worker1 lab3-worker2; do
|
||||
docker run -d --privileged --network lab3-nodes --name "$node" --hostname "$node" docker:29.3-dind --host=unix:///var/run/docker.sock >/dev/null
|
||||
done
|
||||
for node in lab3-manager lab3-worker1 lab3-worker2; do
|
||||
count=0
|
||||
until docker exec "$node" docker info >/dev/null 2>&1; do
|
||||
count=$((count + 1))
|
||||
test "$count" -lt 60 || { echo "$node daemon unavailable" >&2; exit 1; }
|
||||
sleep 1
|
||||
done
|
||||
done
|
||||
manager_ip=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' lab3-manager)
|
||||
manager swarm init --advertise-addr "$manager_ip" >/dev/null
|
||||
join_token=$(manager swarm join-token -q worker)
|
||||
for node in lab3-worker1 lab3-worker2; do
|
||||
docker exec "$node" docker swarm join --token "$join_token" "$manager_ip:2377" >/dev/null
|
||||
manager node update --label-add lab3_compute=true "$node" >/dev/null
|
||||
done
|
||||
manager node update --label-add lab3_storage=true lab3-manager >/dev/null
|
||||
docker build -q -t lab3-api:local . >/dev/null
|
||||
for node in lab3-manager lab3-worker1 lab3-worker2; do
|
||||
docker save lab3-api:local | docker exec -i "$node" docker load >/dev/null
|
||||
done
|
||||
python3 -c 'from pathlib import Path; import sys; lines=Path(".env").read_text().splitlines(); values=[line.split("=",1)[1] for line in lines if line.startswith("POSTGRES_PASSWORD=")]; sys.stdout.write(values[-1])' | docker exec -i lab3-manager docker secret create lab3_db_password - >/dev/null
|
||||
docker exec -i lab3-manager docker config create lab3_haproxy_conf - < infra/haproxy-swarm.cfg >/dev/null
|
||||
docker exec -i lab3-manager docker stack deploy --resolve-image never -c - lab3data < infra/swarm-data.yaml
|
||||
count=0
|
||||
until manager service ls --format '{{.Name}} {{.Replicas}}' | grep -q '^lab3data_postgres 1/1$'; do
|
||||
count=$((count + 1))
|
||||
test "$count" -lt 120 || { manager service ps lab3data_postgres; exit 1; }
|
||||
sleep 1
|
||||
done
|
||||
manager service create --detach=true --name lab3-migrate --network lab3data_data --secret lab3_db_password --env DATABASE_HOST=lab3data_postgres --env DATABASE_NAME=messenger --env DATABASE_USER=messenger --env DATABASE_PASSWORD_FILE=/run/secrets/lab3_db_password --restart-condition on-failure --restart-max-attempts 10 --limit-cpu 0.5 --limit-memory 256M lab3-api:local python -m scripts.migrate >/dev/null
|
||||
count=0
|
||||
until manager service ps --format '{{.CurrentState}}' lab3-migrate | head -1 | grep -q '^Complete'; do
|
||||
count=$((count + 1))
|
||||
test "$count" -lt 90 || { manager service ps lab3-migrate; exit 1; }
|
||||
sleep 1
|
||||
done
|
||||
docker exec -i lab3-manager docker stack deploy --resolve-image never -c - lab3app < infra/swarm-app.yaml
|
||||
echo "Swarm endpoint: http://127.0.0.1:18080 (wait for /health/ready)"
|
||||
;;
|
||||
status)
|
||||
manager node ls
|
||||
manager service ls
|
||||
manager service ps lab3app_api
|
||||
;;
|
||||
fail-node)
|
||||
case "${2:-}" in lab3-worker1|lab3-worker2) docker stop -t 1 "$2" >/dev/null ;; *) echo "Choose lab3-worker1 or lab3-worker2" >&2; exit 2 ;; esac
|
||||
;;
|
||||
recover-node)
|
||||
case "${2:-}" in lab3-worker1|lab3-worker2) docker start "$2" >/dev/null ;; *) echo "Choose lab3-worker1 or lab3-worker2" >&2; exit 2 ;; esac
|
||||
;;
|
||||
rolling-update)
|
||||
manager service update --force --update-parallelism 1 --update-order start-first lab3app_api
|
||||
;;
|
||||
down)
|
||||
echo "Removing the ephemeral synthetic Swarm cluster and its data."
|
||||
docker rm -fv lab3-manager lab3-worker1 lab3-worker2 >/dev/null
|
||||
docker network rm lab3-nodes >/dev/null
|
||||
;;
|
||||
*)
|
||||
echo "Usage: $0 up|status|fail-node WORKER|recover-node WORKER|rolling-update|down" >&2
|
||||
exit 2
|
||||
;;
|
||||
esac
|
||||
@@ -0,0 +1,60 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Check that HAProxy removes a live API with failed database readiness."""
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import time
|
||||
|
||||
from client import Client, Failure
|
||||
|
||||
|
||||
PROJECT = "mtusi2026lab3-yurtaev"
|
||||
TARGET = PROJECT + "-api-1"
|
||||
NETWORK = PROJECT + "_data"
|
||||
|
||||
|
||||
def docker(*args):
|
||||
return subprocess.check_output(["docker", *args], text=True).strip()
|
||||
|
||||
|
||||
def main():
|
||||
client = Client("http://127.0.0.1:8080", timeout=2)
|
||||
alice, _, _, chat = client.bootstrap()
|
||||
target_id = docker("exec", TARGET, "python", "-c",
|
||||
"import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8080/health/live').headers['X-Instance-Id'])")
|
||||
before = {client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"]
|
||||
for _ in range(40)}
|
||||
assert len(before) == 2 and target_id in before, (before, target_id)
|
||||
start = time.monotonic()
|
||||
docker("network", "disconnect", NETWORK, TARGET)
|
||||
try:
|
||||
consecutive = 0
|
||||
errors = 0
|
||||
detected_at = None
|
||||
while time.monotonic() - start < 10:
|
||||
try:
|
||||
response = client.call("GET", "/api/v1/users/me", actor=alice, schema="User")
|
||||
assert response["headers"]["X-Instance-Id"] != target_id
|
||||
consecutive += 1
|
||||
except Failure:
|
||||
errors += 1
|
||||
consecutive = 0
|
||||
if consecutive >= 20:
|
||||
detected_at = time.monotonic() - start
|
||||
break
|
||||
time.sleep(0.05)
|
||||
assert detected_at is not None, "HAProxy did not exclude unready replica"
|
||||
messages = [client.message(alice, chat, "readiness probe " + str(n))["json"] for n in range(10)]
|
||||
assert len({message["id"] for message in messages}) == 10
|
||||
report = {"target_instance_id": target_id, "observed_before": sorted(before),
|
||||
"excluded_within_seconds": round(detected_at, 3), "transient_errors": errors,
|
||||
"successful_writes_after_exclusion": len(messages)}
|
||||
Path("evidence/readiness_failover.json").write_text(json.dumps(report, indent=2) + "\n")
|
||||
print(json.dumps(report, indent=2))
|
||||
finally:
|
||||
docker("network", "connect", NETWORK, TARGET)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+124
@@ -0,0 +1,124 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Inherited lab 2 level 4 checks through the lab 3 load balancer."""
|
||||
|
||||
import base64
|
||||
import concurrent.futures
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
BASE = os.environ.get("BASE_URL", "http://localhost:8080")
|
||||
|
||||
|
||||
def compose(*args, env=None):
|
||||
return subprocess.run(["docker", "compose", "--env-file", ".env", *args], cwd=ROOT, env=env, check=True, capture_output=True, text=True).stdout
|
||||
|
||||
|
||||
def psql(sql):
|
||||
return compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-t", "-A", "-c", sql)
|
||||
|
||||
|
||||
def call(method, path, data=None, auth=None):
|
||||
headers = {"Accept": "application/json"}
|
||||
if method == "POST" and path.endswith("/messages"):
|
||||
headers["Idempotency-Key"] = uuid.uuid4().hex
|
||||
if data is not None:
|
||||
headers["Content-Type"] = "application/json"
|
||||
if auth:
|
||||
headers["Authorization"] = auth
|
||||
request = urllib.request.Request(BASE + path, method=method, headers=headers, data=json.dumps(data).encode() if data is not None else None)
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=10) as response:
|
||||
return response.status, json.loads(response.read() or b"null")
|
||||
except urllib.error.HTTPError as error:
|
||||
return error.code, json.loads(error.read())
|
||||
|
||||
|
||||
def register(name, password):
|
||||
return call("POST", "/api/v1/users", {"username": name, "display_name": "Synthetic", "password": password})
|
||||
|
||||
|
||||
def login(name, password):
|
||||
basic = base64.b64encode((name + ":" + password).encode()).decode()
|
||||
return call("POST", "/api/v1/auth/sessions", auth="Basic " + basic)
|
||||
|
||||
|
||||
def main():
|
||||
assert register("spaces_" + uuid.uuid4().hex[:12], " " * 12)[0] == 400
|
||||
name = "race_" + uuid.uuid4().hex[:12]
|
||||
password = "synthetic-" + uuid.uuid4().hex
|
||||
gate = threading.Barrier(16)
|
||||
def competing_register(_):
|
||||
gate.wait()
|
||||
return register(name, password)[0]
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=16) as workers:
|
||||
statuses = list(workers.map(competing_register, range(16)))
|
||||
assert statuses.count(201) == 1 and statuses.count(409) == 15, statuses
|
||||
status, session = login(name, password)
|
||||
assert status == 201
|
||||
basic = base64.b64encode((name + ":" + password).encode()).decode()
|
||||
assert call("POST", "/api/v1/auth/sessions", {"unexpected": "body"}, "Basic " + basic)[0] == 400
|
||||
token = "Bearer " + session["token"]
|
||||
user_id = session["user"]["id"]
|
||||
status, chat = call("POST", "/api/v1/chats", {"title": "Failure test", "member_ids": [user_id]}, token)
|
||||
assert status == 201
|
||||
probe = "rollback_" + uuid.uuid4().hex
|
||||
psql("CREATE FUNCTION lab2_rollback_guard() RETURNS trigger LANGUAGE plpgsql AS $$ "
|
||||
f"BEGIN IF EXISTS (SELECT 1 FROM chats WHERE id=NEW.chat_id AND title='{probe}') "
|
||||
"THEN RAISE EXCEPTION 'rollback probe'; END IF; RETURN NEW; END $$;")
|
||||
psql("CREATE TRIGGER lab2_rollback_guard BEFORE INSERT ON chat_members "
|
||||
"FOR EACH ROW EXECUTE FUNCTION lab2_rollback_guard();")
|
||||
try:
|
||||
assert call("POST", "/api/v1/chats", {"title": probe, "member_ids": [user_id]}, token)[0] == 500
|
||||
assert psql(f"SELECT count(*) FROM chats WHERE title='{probe}'").strip() == "0"
|
||||
finally:
|
||||
psql("DROP TRIGGER lab2_rollback_guard ON chat_members; DROP FUNCTION lab2_rollback_guard();")
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert call("POST", path, {"text": "before outage"}, token)[0] == 201
|
||||
malformed = base64.urlsafe_b64encode(json.dumps([chat["id"], 17, user_id]).encode()).decode().rstrip("=")
|
||||
assert call("GET", path + "?cursor=" + malformed, auth=token)[0] == 400
|
||||
assert call("GET", path + "?limit=" + "9" * 100, auth=token)[0] == 400
|
||||
missing_status, missing_body = call("GET", "/api/v1/missing", auth=token)
|
||||
assert missing_status == 404 and missing_body["error"]["code"] == "not_found"
|
||||
compose("stop", "redis")
|
||||
try:
|
||||
assert call("GET", path, auth=token)[0] == 200
|
||||
assert call("POST", path, {"text": "during cache outage"}, token)[0] == 201
|
||||
assert call("GET", path, auth=token)[1]["items"][-1]["text"] == "during cache outage"
|
||||
assert call("GET", "/api/v1/users/me", auth="Bearer invalid")[0] == 401
|
||||
finally:
|
||||
compose("start", "redis")
|
||||
compose("stop", "postgres")
|
||||
try:
|
||||
assert call("GET", "/health/ready")[0] == 503
|
||||
assert call("GET", "/api/v1/users/me", auth=token)[0] == 503
|
||||
finally:
|
||||
compose("start", "postgres")
|
||||
for _ in range(40):
|
||||
if call("GET", "/health/ready")[0] == 200:
|
||||
break
|
||||
time.sleep(0.5)
|
||||
else:
|
||||
raise AssertionError("PostgreSQL did not recover")
|
||||
# Expiry is checked against PostgreSQL time, without a Redis dependency.
|
||||
env = dict(os.environ, SESSION_TTL_SECONDS="2")
|
||||
compose("up", "-d", "--force-recreate", "--wait", "api", env=env)
|
||||
try:
|
||||
short = login(name, password)[1]["token"]
|
||||
time.sleep(3)
|
||||
assert call("GET", "/api/v1/users/me", auth="Bearer " + short)[0] == 401
|
||||
finally:
|
||||
compose("up", "-d", "--force-recreate", "--wait", "api")
|
||||
print("PASS: username race, chat rollback, Redis fallback, PostgreSQL failure, session expiry")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,138 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Exercise a real Swarm worker loss while reading and writing through the LB."""
|
||||
|
||||
import argparse
|
||||
from collections import Counter
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
import json
|
||||
from pathlib import Path
|
||||
import statistics
|
||||
import subprocess
|
||||
import time
|
||||
import uuid
|
||||
from urllib.parse import quote
|
||||
|
||||
from client import Client, Failure
|
||||
|
||||
|
||||
def tasks():
|
||||
result = subprocess.check_output([
|
||||
"docker", "exec", "lab3-manager", "docker", "service", "ps",
|
||||
"--filter", "desired-state=running", "--format", "{{.ID}} {{.Node}} {{.CurrentState}}",
|
||||
"lab3app_api",
|
||||
], text=True)
|
||||
return [{"task_id": parts[0], "node": parts[1]} for line in result.splitlines()
|
||||
if len(parts := line.split()) >= 3 and parts[2] == "Running"]
|
||||
|
||||
|
||||
def history(client, actor, chat):
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100"
|
||||
items = []
|
||||
for _ in range(100):
|
||||
page = client.call("GET", path, actor=actor, schema="MessagePage")["json"]
|
||||
items.extend(page["items"])
|
||||
if page["next_cursor"] is None:
|
||||
return items
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100&cursor=" + quote(page["next_cursor"], safe="")
|
||||
raise AssertionError("history pagination did not terminate")
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--base-url", default="http://127.0.0.1:18080")
|
||||
parser.add_argument("--worker", choices=["lab3-worker1", "lab3-worker2"], default="lab3-worker1")
|
||||
parser.add_argument("--output", default="evidence/node_failover.json")
|
||||
args = parser.parse_args()
|
||||
client = Client(args.base_url, timeout=2)
|
||||
alice, bob, _, chat = client.bootstrap()
|
||||
before = tasks()
|
||||
assert len(before) == 2 and args.worker in {task["node"] for task in before}, before
|
||||
instances = {
|
||||
client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"]
|
||||
for _ in range(40)
|
||||
}
|
||||
assert len(instances) == 2, instances
|
||||
|
||||
key = uuid.uuid4().hex
|
||||
body = "concurrent " + key
|
||||
with ThreadPoolExecutor(max_workers=16) as executor:
|
||||
responses = list(executor.map(lambda _: client.message(alice, chat, body, key=key), range(16)))
|
||||
results = [response["json"] for response in responses]
|
||||
concurrent_instances = {response["headers"]["X-Instance-Id"] for response in responses}
|
||||
assert all(item == results[0] for item in results)
|
||||
assert len(concurrent_instances) >= 2, concurrent_instances
|
||||
|
||||
start = time.monotonic()
|
||||
subprocess.run(["docker", "stop", "-t", "1", args.worker], check=True, stdout=subprocess.DEVNULL)
|
||||
stop_return_seconds = time.monotonic() - start
|
||||
successes = {}
|
||||
post_errors = 0
|
||||
read_errors = 0
|
||||
successful_reads = 0
|
||||
latencies = []
|
||||
moved_at = None
|
||||
first_success = None
|
||||
pending_key = uuid.uuid4().hex
|
||||
pending_text = "node-fail " + pending_key
|
||||
while time.monotonic() - start < 75:
|
||||
try:
|
||||
response = client.message(alice, chat, pending_text, key=pending_key)
|
||||
assert pending_key not in successes
|
||||
successes[pending_key] = response["json"]
|
||||
latest_id = response["json"]["id"]
|
||||
latencies.append(response["elapsed"] * 1000)
|
||||
if first_success is None:
|
||||
first_success = time.monotonic() - start
|
||||
pending_key = uuid.uuid4().hex
|
||||
pending_text = "node-fail " + pending_key
|
||||
except Failure:
|
||||
post_errors += 1
|
||||
else:
|
||||
try:
|
||||
assert latest_id in {item["id"] for item in history(client, bob, chat)}
|
||||
successful_reads += 1
|
||||
except Failure:
|
||||
read_errors += 1
|
||||
current = tasks()
|
||||
if len(current) == 2 and args.worker not in {task["node"] for task in current} and moved_at is None:
|
||||
moved_at = time.monotonic() - start
|
||||
if moved_at is not None and time.monotonic() - start > moved_at + 5:
|
||||
break
|
||||
time.sleep(0.15)
|
||||
assert moved_at is not None, tasks()
|
||||
assert successes, "no writes during node failure"
|
||||
items = history(client, bob, chat)
|
||||
ids = Counter(item["id"] for item in items)
|
||||
texts = Counter(item["text"] for item in items)
|
||||
assert ids[results[0]["id"]] == 1 and texts[body] == 1
|
||||
assert all(ids[item["id"]] == 1 and texts[item["text"]] == 1 for item in successes.values())
|
||||
after_instances = {
|
||||
client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"]
|
||||
for _ in range(40)
|
||||
}
|
||||
assert after_instances - instances, (instances, after_instances)
|
||||
report = {
|
||||
"before_tasks": before,
|
||||
"after_tasks": tasks(),
|
||||
"before_instance_ids": sorted(instances),
|
||||
"after_instance_ids": sorted(after_instances),
|
||||
"concurrent_replays": len(results),
|
||||
"concurrent_message_count": 1,
|
||||
"concurrent_instance_ids": sorted(concurrent_instances),
|
||||
"successful_writes": len(successes),
|
||||
"successful_reads": successful_reads,
|
||||
"failed_post_attempts": post_errors,
|
||||
"failed_read_attempts": read_errors,
|
||||
"docker_stop_seconds": round(stop_return_seconds, 3),
|
||||
"first_success_seconds": round(first_success, 3),
|
||||
"replacement_running_seconds": round(moved_at, 3),
|
||||
"confirmed_messages_preserved": True,
|
||||
"latency_p50_ms": round(statistics.median(latencies), 3),
|
||||
"latency_p95_ms": round(sorted(latencies)[int(0.95 * (len(latencies) - 1))], 3),
|
||||
}
|
||||
Path(args.output).write_text(json.dumps(report, indent=2) + "\n")
|
||||
print(json.dumps(report, indent=2))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user