3 Commits
Author SHA1 Message Date
yurtaev.va 088961a433 lab3: second tiny fix 2026-10-23 19:29:40 +03:00
yurtaev.va 3a3302c5b4 lab3: tiny fix 2026-10-23 19:03:42 +03:00
yurtaev.va 2e23dbe095 feat: lab3 init 2026-10-23 18:54:43 +03:00
33 changed files with 1666 additions and 55 deletions
+4 -11
View File
@@ -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
+10 -14
View File
@@ -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
View File
@@ -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"]
+5 -1
View File
@@ -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)
+78 -23
View File
@@ -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 использует привилегированные контейнеры только для учебного эксперимента.
View File
+500
View File
@@ -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
View File
@@ -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
View File
@@ -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).
+11
View File
@@ -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
+46
View File
@@ -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
}
+10
View File
@@ -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
}
+17
View File
@@ -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."
}
+17
View File
@@ -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."
}
+86
View File
@@ -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
+3
View File
@@ -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
View File
@@ -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` остаётся шаблоном задания.
+27
View File
@@ -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
+27
View File
@@ -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
+68
View File
@@ -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
+41
View File
@@ -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
+38
View File
@@ -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);
+10
View File
@@ -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);
+4
View File
@@ -0,0 +1,4 @@
fastapi==0.115.12
uvicorn==0.34.2
psycopg[binary,pool]==3.2.6
redis==5.2.1
+50
View File
@@ -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()
+49
View File
@@ -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())
+16
View File
@@ -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()
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres redis api lb >/dev/null
+12
View File
@@ -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
+78
View File
@@ -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
+60
View File
@@ -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
View File
@@ -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()
+138
View File
@@ -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()