Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
37ea282e21 |
+10
-9
@@ -1,13 +1,14 @@
|
||||
# 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
|
||||
APP_PORT=8080
|
||||
# Скопируйте в .env. Файл .env не коммитить.
|
||||
# Пароль ниже — учебная заглушка локального стенда, не боевой секрет.
|
||||
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
|
||||
SESSION_STORE=valkey
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=local-only-change-me
|
||||
POSTGRES_DB=messenger
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
DRAIN_SECONDS=3
|
||||
# Не задавайте INSTANCE_ID: иначе все реплики получат один X-Instance-Id.
|
||||
# DATABASE_URL и REDIS_URL собирает compose.yaml и передаёт только api/migrate.
|
||||
# DATABASE_URL_FILE и CACHE_URL_FILE приложение тоже умеет читать, если файл есть.
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
*.sh text eol=lf
|
||||
*.cfg text eol=lf
|
||||
compose.yaml text eol=lf
|
||||
Dockerfile text eol=lf
|
||||
.env.example text eol=lf
|
||||
@@ -1,18 +1,18 @@
|
||||
## Лабораторная 3
|
||||
|
||||
Автор / группа: TODO
|
||||
Целевая оценка (3/4/5): TODO
|
||||
Трек 5, если заявлен: TODO
|
||||
Автор / группа: Боцоев Арсен, БВТ2303
|
||||
Целевая оценка (3/4/5): 4
|
||||
Трек 5, если заявлен: нет
|
||||
|
||||
Что реализовано и что перенесено: TODO
|
||||
Команды запуска из чистого clone: TODO
|
||||
Результаты проверок и ссылка на REPORT.md: TODO
|
||||
Ограничения / известные ошибки: TODO
|
||||
Источники и использование ИИ: TODO
|
||||
Что реализовано и что перенесено: из lab2 перенесены PostgreSQL, Valkey-сессии, scrypt и миграции. Добавлены Traefik, две реплики API без опубликованных портов, общий Idempotency-Key, drain по SIGTERM, scripts/stop-one.sh, scripts/restart.sh и scripts/rolling-update.sh.
|
||||
Команды запуска из чистого clone: см. REPORT.md
|
||||
Результаты проверок и ссылка на REPORT.md: make check, smoke, persistence и failover прошли; цифры отказа и rolling update в REPORT.md и evidence/
|
||||
Ограничения / известные ошибки: см. раздел ограничений в REPORT.md
|
||||
Источники и использование ИИ: PostgreSQL advisory lock, Traefik Docker provider, RFC 7617, hashlib.scrypt, psycopg 3, redis-py. Реализацию помог собрать ИИ в Cursor.
|
||||
|
||||
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [ ] Контракт и публичные тесты не ослаблены.
|
||||
- [ ] make check и make test выполнены; приложен реальный вывод.
|
||||
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
|
||||
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
|
||||
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
|
||||
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [x] Контракт и публичные тесты не ослаблены.
|
||||
- [x] make check и make test выполнены; приложен реальный вывод.
|
||||
- [x] Сценарии отказов/безопасности своего уровня воспроизведены.
|
||||
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
|
||||
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
|
||||
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
# syntax=docker/dockerfile:1.7
|
||||
FROM python:3.12.6-slim-bookworm
|
||||
|
||||
RUN groupadd --system --gid 10001 app \
|
||||
&& useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app
|
||||
|
||||
WORKDIR /app
|
||||
COPY requirements.txt /app/requirements.txt
|
||||
RUN pip install --no-cache-dir -r /app/requirements.txt
|
||||
|
||||
COPY --chown=app:app src/ /app/
|
||||
COPY --chown=app:app migrations/ /app/migrations/
|
||||
|
||||
USER app
|
||||
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080 \
|
||||
APP_ENV=lab
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
ARG BUILD_ID=dev
|
||||
LABEL lab.build-id=$BUILD_ID
|
||||
|
||||
STOPSIGNAL SIGTERM
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=8s --retries=5 \
|
||||
CMD python3 -c "import urllib.request,sys; urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2); sys.exit(0)"
|
||||
|
||||
CMD ["python3", "/app/server.py"]
|
||||
@@ -1,37 +1,204 @@
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Автор, группа: Боцоев Арсен, БВТ2303
|
||||
- Целевая оценка: 4
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Использованные источники, библиотеки и помощь ИИ: PostgreSQL advisory lock, Traefik Docker provider, RFC 7617, hashlib.scrypt, psycopg 3, redis-py. Реализацию сервера, Compose и проверок помог собрать ИИ в Cursor.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Docker Engine 24+ с Compose v2 и Python 3.9+ для публичных тестов. Приложение в контейнере — Python 3.12.6. Команды ниже — для `sh` в Linux или WSL; из PowerShell блок целиком не выполняется. Порт 8080 на `127.0.0.1` должен быть свободен: его публикует только `lb`. Проверка ниже выполнена в WSL Ubuntu 26.04: Docker 29.4.2, Compose 5.1.3, Python 3.14.4. На Windows у `python` без `PYTHONUTF8=1` публичный `make check` может не прочитать `openapi.json` в кодировке cp1251; в Linux/WSL это не требуется.
|
||||
|
||||
```sh
|
||||
cd mtusi2026lab3
|
||||
cp .env.example .env
|
||||
# в .env учебный POSTGRES_PASSWORD, файл не коммитить
|
||||
chmod +x scripts/up.sh scripts/restart.sh scripts/stop-one.sh scripts/restore-api.sh scripts/rolling-update.sh
|
||||
docker compose --env-file .env -f compose.yaml config --quiet
|
||||
docker compose --env-file .env -f compose.yaml up -d --build --scale api=2 --remove-orphans
|
||||
```
|
||||
|
||||
Тот же запуск одной командой: `sh scripts/up.sh`. Миграции применяет одноразовый сервис `migrate` до старта реплик.
|
||||
|
||||
Дальше один сценарий. Сначала дождаться готовности и увидеть две реплики API без порта на хосте: наружу только `127.0.0.1:8080` у `lb`. Затем проверки уровня 3. После persistence — повтор миграций: в `schema_migrations` остаются две строки, по одной на `001_init.sql` и `002_idempotency.sql`. Failover оставляет одну реплику остановленной; `docker compose ps` это показывает. Перед `grade4_probe.py` её нужно поднять и дождаться, пока обе снова healthy: probe сам останавливает каждую реплику по очереди, собирает RPS и делает rolling update, и для старта ему нужны оба `X-Instance-Id`. Probe перезаписывает `evidence/grade4.json`.
|
||||
|
||||
```sh
|
||||
python3 - <<'PY'
|
||||
import time
|
||||
import urllib.request
|
||||
deadline = time.time() + 120
|
||||
while True:
|
||||
try:
|
||||
body = urllib.request.urlopen("http://127.0.0.1:8080/health/ready", timeout=2).read().decode()
|
||||
except Exception:
|
||||
if time.time() > deadline:
|
||||
raise SystemExit("GET /health/ready не стал 200 за 120 с")
|
||||
time.sleep(2)
|
||||
continue
|
||||
print(body)
|
||||
break
|
||||
PY
|
||||
docker compose --env-file .env -f compose.yaml ps
|
||||
|
||||
# make check и make test
|
||||
python3 scripts/check_contract.py
|
||||
python3 tests/smoke.py --base-url http://127.0.0.1:8080
|
||||
python3 tests/student_level4.py --base-url http://127.0.0.1:8080
|
||||
# make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080
|
||||
|
||||
docker compose --env-file .env -f compose.yaml run --rm --no-deps migrate
|
||||
docker compose --env-file .env -f compose.yaml exec -T postgres \
|
||||
sh -c 'psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -c "SELECT version, count(*) FROM schema_migrations GROUP BY version ORDER BY version;"'
|
||||
|
||||
# make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
python3 tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080
|
||||
docker compose --env-file .env -f compose.yaml ps
|
||||
sh scripts/restore-api.sh
|
||||
i=0
|
||||
n=0
|
||||
while [ "$i" -lt 40 ]; do
|
||||
n=0
|
||||
for id in $(docker compose --env-file .env -f compose.yaml ps -q api); do
|
||||
status=$(docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' "$id")
|
||||
if [ "$status" = "healthy" ]; then
|
||||
n=$((n + 1))
|
||||
fi
|
||||
done
|
||||
if [ "$n" -ge 2 ]; then
|
||||
break
|
||||
fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
if [ "$n" -lt 2 ]; then
|
||||
echo "две реплики api не стали healthy" >&2
|
||||
exit 1
|
||||
fi
|
||||
python3 scripts/grade4_probe.py
|
||||
```
|
||||
|
||||
Остановка без удаления данных:
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env -f compose.yaml stop
|
||||
```
|
||||
|
||||
Удаление учебных данных вместе с volumes:
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env -f compose.yaml down -v
|
||||
```
|
||||
|
||||
Образы закреплены тегами: `python:3.12.6-slim-bookworm`, `postgres:16.6-bookworm`, `valkey/valkey:8.0.2`, `traefik:v3.7.16`. Зависимости Python закреплены в `requirements.txt`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
Клиент --HTTP--> Traefik (lb) --HTTP--> API ×2 (src/server.py)
|
||||
|--SQL--> PostgreSQL
|
||||
+--сессия--> Valkey (AOF + volume)
|
||||
```
|
||||
|
||||
Из lab2 перенесены пользователи, чаты, членство, сообщения, keyset-пагинация, формат ошибок, `X-Request-Id`, Basic/Bearer, scrypt и сессии в Valkey. Локальной памяти, от которой зависит корректность, у API нет: сессии в общем Valkey, сообщения и ключи идемпотентности в общем PostgreSQL. `X-Instance-Id` — hostname контейнера, стабильный на время жизни процесса. В Compose hostname совпадает с коротким id контейнера, поэтому `scripts/stop-one.sh` находит реплику по `TARGET_INSTANCE_ID`.
|
||||
|
||||
Sticky cookie нет. Traefik распределяет запросы по живым контейнерам сервиса `api`. Адреса он берёт из Docker API и обновляет по событиям start/die, а не из одного закэшированного DNS-ответа. Сокет Docker смонтирован только в `lb` и только на чтение.
|
||||
|
||||
### Соответствие .env
|
||||
|
||||
| Переменная | Куда попадает |
|
||||
| --- | --- |
|
||||
| `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB` | `postgres`; из них же `DATABASE_URL` у `migrate` и `api` |
|
||||
| `SESSION_TTL_SECONDS` | API, TTL сессии в Valkey |
|
||||
| `IDEMPOTENCY_TTL_SECONDS` | API, окно повторного ключа, по умолчанию 86400 |
|
||||
| `DRAIN_SECONDS` | API, пауза после SIGTERM до закрытия сокета, по умолчанию 3 |
|
||||
| `API_REPLICAS` | `scripts/up.sh` и `scripts/restore-api.sh`, масштаб сервиса `api` |
|
||||
| `REDIS_URL` | задаёт compose только сервису `api`: `redis://valkey:6379/0` |
|
||||
|
||||
`INSTANCE_ID` в окружение реплик не передаётся: иначе обе получили бы один и тот же заголовок. `DATABASE_URL_FILE` и `CACHE_URL_FILE` приложение читает, если файл есть; этот стенд передаёт URL переменными и только тем сервисам, которым они нужны. Пароль Valkey нет: порт 6379 наружу не опубликован. Это учебное упрощение локального стенда.
|
||||
|
||||
### Идемпотентность
|
||||
|
||||
Область ключа: пользователь + `POST` + путь `/api/v1/chats/{id}/messages` + `Idempotency-Key`. Канонический вид тела — JSON с отсортированными ключами, где отсутствующий `attachment_ids` равен `[]`. В lab3 схема `CreateMessage` принимает только `text`; лишнее поле отклоняется с 400 до записи ключа, поэтому порядок ключей у валидного тела не создаёт второе сообщение.
|
||||
|
||||
Одинаковый ключ сериализуется `pg_advisory_xact_lock`. `INSERT` сообщения и `INSERT` в `idempotency_keys` — одна транзакция. Обрыв до COMMIT не оставляет ни сообщения, ни «окончательного» результата, поэтому тот же ключ можно безопасно повторить. Повтор того же канонического тела в течение TTL возвращает тот же 201 и ту же строку `messages`. Другое тело — 409. На повторе снова проверяются сессия и членство в чате. Чужой чат и пустой текст ключ не занимают.
|
||||
|
||||
### Миграции
|
||||
|
||||
Их запускает только `migrate` (`python3 /app/migrate.py`), один процесс, под `pg_advisory_lock`. Реплики API миграции не выполняют. `002_idempotency.sql` добавляет таблицу и совместим с уже работающим кодом lab2: старый процесс эту таблицу не читает. Rolling update схему не меняет. Ломающее изменение колонки при ещё живых старых репликах этот стенд не поддерживает.
|
||||
|
||||
### Health, таймауты, SIGTERM
|
||||
|
||||
| Узел | Настройка |
|
||||
| --- | --- |
|
||||
| API `/health/live` | 200, пока процесс жив, в том числе во время drain |
|
||||
| API `/health/ready` | 200, если не идёт остановка и доступны PostgreSQL и Valkey; иначе 503 |
|
||||
| Traefik healthcheck | `GET /health/ready` каждые 1 с, timeout 1 с |
|
||||
| Исключение backend | одна неуспешная проверка убирает реплику из балансировки |
|
||||
| Верхняя оценка обнаружения | 1 с до следующей проверки + 1 с timeout = 2 с |
|
||||
| Клиент и upstream Traefik | dial 1 с, ответ 8 с, idle 5 с / 1 с |
|
||||
| SIGTERM API | сразу 503 на `/health/ready` и на новые бизнес-запросы; сокет закрывается через `DRAIN_SECONDS` (3 с) |
|
||||
| `stop_grace_period` API | 10 с; `scripts/stop-one.sh` вызывает `docker stop -t 8` |
|
||||
| Docker healthcheck API | `/health/ready`, интервал 2 с |
|
||||
|
||||
Пока реплика уже отдаёт 503, но ещё не вышла, Traefik перестаёт слать ей новые запросы. Краткие обрывы до этого момента возможны и измеряются ниже. `restart: unless-stopped` поднимает контейнер после падения процесса и не поднимает его после `docker stop`.
|
||||
|
||||
### Лимиты и порты
|
||||
|
||||
Проверено `docker inspect` во время `scripts/grade4_probe.py` (`evidence/grade4.json`, поле `container_limits`):
|
||||
|
||||
| Сервис | CPU | RAM | Порт на хосте |
|
||||
| --- | --- | --- | --- |
|
||||
| api | 0.50 | 256 MiB | нет |
|
||||
| lb | 0.25 | 128 MiB | 127.0.0.1:8080 |
|
||||
| postgres | 0.75 | 512 MiB | нет |
|
||||
| valkey | 0.25 | 128 MiB | нет |
|
||||
| migrate | 0.50 | 256 MiB | нет, одноразовый контейнер |
|
||||
|
||||
`container_name` нет, сервис `api` масштабируется `--scale`.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
Стенд: WSL2, 16 CPU на машине, лимиты контейнеров — из таблицы выше. Нагрузка — closed-loop POST, concurrency 4, timeout клиента 3 с, без повторов на клиенте. Это подтверждения HTTP, не замер предела БД. Дата прогона: 2026-10-30.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | `python3 tests/smoke.py --base-url http://127.0.0.1:8080` | PASS | evidence/smoke.txt |
|
||||
| Offline-структура | `python3 scripts/check_contract.py` | PASS | evidence/smoke.txt |
|
||||
| Две реплики, один вход, общая БД и сессии | `docker compose ps`, 30 GET `/users/me` | Два разных `X-Instance-Id` на одной сессии: `2d295e897529`, `3770bdb4bd34`. Порт только у lb. Postgres и Valkey без портов на хосте | evidence/level4.txt, evidence/grade4.json |
|
||||
| Отказ одной реплики ≤ 10 с | `tests/resilience.py --mode failover --action-script scripts/stop-one.sh` | 2 реплики до отказа; 136 успешных записей; 1 ошибка; первое успешное восстановление 3.76 с. `api-4` остался Exited, `api-3` healthy | evidence/failover.txt |
|
||||
| Идемпотентность, в том числе гонка | `tests/student_level4.py` и блок parallel в probe | 8 параллельных POST, один id сообщения, оба instance id. Другое тело — 409. История без дубля | evidence/level4.txt, evidence/grade4.json |
|
||||
| Сохранность токена и сообщений | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS. Перезапущены api, postgres, valkey. Volumes `mtusi-lab3_pgdata` и `mtusi-lab3_valkeydata` на месте | evidence/persistence.txt |
|
||||
| Health/readiness и SIGTERM согласованы, LB убирает backend | конфиг `infra/traefik.yml`, drain в `src/server.py`, probe | Период проверки 1 с, максимум обнаружения 2 с. Hook `docker stop` вернулся за 3.73 с и 3.68 с. После возврата hook целевой id в успешных ответах отсутствует | evidence/grade4.json |
|
||||
| По очереди остановить каждую реплику, собрать RPS и ошибки | `python3 scripts/grade4_probe.py` | База: 117 rps, 0 ошибок, p50 11.6 мс, p95 97 мс. Отказ первой: 60 rps, 23 ошибки за 9.7 с, чужая реплика ответила через 0.028 с, свой id вернулся через 6.7 с после start. Отказ второй: 64 rps, 67 ошибок, чужая реплика через 0.038 с, восстановление id 5.9 с | evidence/grade4.json |
|
||||
| Параллельный один ключ через разные реплики | 8 потоков в probe и student_level4 | `unique_message_ids=1`, оба instance id | evidence/grade4.json |
|
||||
| CPU/RAM, нет обхода LB, нет container_name | `docker inspect` внутри probe | Лимиты из таблицы выше. У API `8080/tcp` без HostPort | evidence/grade4.json |
|
||||
| Rolling update под нагрузкой | `scripts/rolling-update.sh` во время той же нагрузки | exit 0, 25.2 с, 2724 успеха, 154 ошибки (5.4%), 108 rps. Образ сменился с `sha256:677eedd39f22` на `sha256:1de321e159c5`. В окне видны и старые, и новые id | evidence/grade4.json |
|
||||
| Миграции один раз и совместимы | `select version from schema_migrations` | Две строки, по одной на версию: `001_init.sql`, `002_idempotency.sql`. Повторный migrate строки не удвоил. API миграции не запускает. 002 только добавляет таблицу | evidence/persistence.txt |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Гипотеза: при остановке одной из двух реплик живая продолжит чтение и запись быстрее чем за 10 с, а один `Idempotency-Key` не создаст второе сообщение даже при параллельных POST.
|
||||
|
||||
Профиль: closed-loop POST сообщений, 4 потока, timeout 3 с, без клиентских retry. Прогрев — 8 с baseline. Окно отказа — время `docker stop` плюс 6 с. Rolling шёл под той же нагрузкой 25 с. Один прогон. Аппаратные лимиты — таблица сервисов, не вся машина (16 CPU, память WSL 7.5 GiB).
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Baseline, обе реплики | Оба id, ошибки около нуля | 935 успехов, 0 ошибок, 117 rps, p50/p95/p99 = 11.6/97/173 мс | — |
|
||||
| `stop-one.sh` для `2d295e897529` | Запись продолжается на второй реплике, ключ не двоит | 579 успехов, 23 ошибки (3.8%), 60 rps. После возврата hook целевого id в успехах нет | Успех на другой реплике через 0.028 с от старта stop. Тот же id снова виден через 6.7 с после restore. Потери подтверждённых сообщений нет |
|
||||
| `stop-one.sh` для `3770bdb4bd34` | То же для второй реплики | 618 успехов, 67 ошибок (9.8%), 64 rps | 0.038 с до чужой реплики, 5.9 с до возврата своего id |
|
||||
| Публичный failover | ≥2 id до отказа, восстановление ≤ 10 с, остановленная реплика не обслуживает | 2 id, 136 успехов, 1 ошибка, first_recovery 3.76 с. `api-4` Exited, `api-3` healthy | 3.76 с от старта hook. Подтверждённые сообщения и сессия на месте |
|
||||
| Rolling update под нагрузкой | Поочерёдная замена, сервис остаётся доступен | exit 0, 154 ошибки на 2724 успеха, образ сменился | Окно 25.2 с, rps 108. Дублей из-за замены не измерялось отдельно: каждая запись нагрузки имеет свой ключ |
|
||||
| Рестарт api+postgres+valkey | Старый токен и сообщение живы, volume на месте | PASS публичного persistence | Volumes не удалялись |
|
||||
|
||||
Падение rps примерно вдвое при одной реплике совпадает с тем, что упор этого профиля — CPU API, а не отказ LB. 23 и 67 ошибок в окнах отказа — запросы, которые попали в реплику в первые секунды drain, пока Traefik ещё не снял её с балансировки. Клиент их не повторял; в публичном тесте неопределённый POST повторяется с тем же ключом, дубля нет.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Выдерживается остановка одного процесса API при живых LB, PostgreSQL и Valkey. Не выдерживается отказ узла, отказ самого LB и отказ PostgreSQL: это одна машина и одна БД. Падение Valkey делает `/health/ready` равным 503, потому что без общего хранилища сессий реплики разошлись бы.
|
||||
|
||||
Valkey без пароля и пароль БД в переменных compose — упрощение локального стенда. Сокет Docker у Traefik даёт балансировщику право читать состояние контейнеров; наружу этот сокет не публикуется.
|
||||
|
||||
Просроченные ключи идемпотентности удаляются при следующем использовании того же ключа, а не фоновой уборкой. `scripts/rolling-update.sh` вызывает `docker build`. В этом прогоне сборка шла через BuildKit, образ подменился, что видно по смене sha256. Схема во время rolling не мигрирует.
|
||||
|
||||
117 rps — closed-loop с четырьмя потоками на localhost, с coordinated omission. Это не предел стенда и не результат трека 5.
|
||||
|
||||
+154
@@ -0,0 +1,154 @@
|
||||
# Локальный стенд lab3: клиент → Traefik → API ×2 → PostgreSQL + Valkey.
|
||||
# Публичный порт только у lb. У API нет ports и нет container_name.
|
||||
# Миграции выполняет одноразовый сервис migrate, не каждая реплика.
|
||||
name: mtusi-lab3
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.6-bookworm
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
shm_size: 128mb
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
start_period: 5s
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 20s
|
||||
networks: [lab]
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.75"
|
||||
memory: 512M
|
||||
|
||||
valkey:
|
||||
image: valkey/valkey:8.0.2
|
||||
command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec", "--save", "60", "1"]
|
||||
volumes:
|
||||
- valkeydata:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "valkey-cli", "ping"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
start_period: 3s
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 10s
|
||||
networks: [lab]
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.25"
|
||||
memory: 128M
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
image: mtusi-messenger:lab3
|
||||
command: ["python3", "/app/migrate.py"]
|
||||
environment:
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
networks: [lab]
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 256M
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtusi-messenger:lab3
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SESSION_STORE: valkey
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
DRAIN_SECONDS: ${DRAIN_SECONDS:-3}
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
REDIS_URL: redis://valkey:6379/0
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
valkey:
|
||||
condition: service_healthy
|
||||
expose:
|
||||
- "8080"
|
||||
labels:
|
||||
- traefik.enable=true
|
||||
- traefik.docker.network=mtusi-lab3-net
|
||||
- traefik.http.routers.messenger.rule=PathPrefix(`/`)
|
||||
- traefik.http.routers.messenger.entrypoints=web
|
||||
- traefik.http.services.messenger.loadbalancer.server.port=8080
|
||||
- traefik.http.services.messenger.loadbalancer.healthcheck.path=/health/ready
|
||||
- traefik.http.services.messenger.loadbalancer.healthcheck.interval=1s
|
||||
- traefik.http.services.messenger.loadbalancer.healthcheck.timeout=1s
|
||||
- traefik.http.services.messenger.loadbalancer.healthcheck.scheme=http
|
||||
- traefik.http.services.messenger.loadbalancer.passhostheader=true
|
||||
healthcheck:
|
||||
test:
|
||||
- CMD
|
||||
- python3
|
||||
- -c
|
||||
- import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 8
|
||||
start_period: 8s
|
||||
init: true
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 10s
|
||||
stop_signal: SIGTERM
|
||||
networks: [lab]
|
||||
deploy:
|
||||
replicas: 2
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 256M
|
||||
|
||||
lb:
|
||||
image: traefik:v3.7.16
|
||||
command: ["--configFile=/etc/traefik/traefik.yml"]
|
||||
volumes:
|
||||
- ./infra/traefik.yml:/etc/traefik/traefik.yml:ro
|
||||
- /var/run/docker.sock:/var/run/docker.sock:ro
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8082/ping"]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 8
|
||||
start_period: 3s
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 5s
|
||||
networks: [lab]
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.25"
|
||||
memory: 128M
|
||||
|
||||
networks:
|
||||
lab:
|
||||
name: mtusi-lab3-net
|
||||
driver: bridge
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
valkeydata:
|
||||
@@ -0,0 +1,18 @@
|
||||
Дата: 2026-10-30
|
||||
Команда:
|
||||
|
||||
python3 tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080
|
||||
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
|
||||
{"observed_instances_before": 2, "successful_writes": 136, "failed_attempts": 1, "first_recovery_seconds": 3.756}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
|
||||
Сразу после теста:
|
||||
mtusi-lab3-api-4 Exited (0) — остановлен hook и оставлен остановленным
|
||||
mtusi-lab3-api-3 Up (healthy) — продолжал обслуживать LB
|
||||
|
||||
X-Instance-Id совпадает с hostname контейнера. stop-one.sh ищет контейнер сервиса api
|
||||
с этим hostname или с коротким id и вызывает docker stop -t 8.
|
||||
restart: unless-stopped после docker stop контейнер сам не поднимает.
|
||||
|
||||
Поочерёдный отказ каждой реплики и цифры RPS — в evidence/grade4.json.
|
||||
@@ -0,0 +1,169 @@
|
||||
{
|
||||
"date": "2026-10-30T17:29:30Z",
|
||||
"platform": "Linux-6.18.54.1-microsoft-standard-WSL2-x86_64-with-glibc2.43",
|
||||
"cpu_count": 16,
|
||||
"workload": "closed-loop POST, concurrency 4, client timeout 3s, no client retry",
|
||||
"observed_instances": [
|
||||
"2d295e897529",
|
||||
"3770bdb4bd34"
|
||||
],
|
||||
"parallel_idempotency": {
|
||||
"requests": 8,
|
||||
"unique_message_ids": 1,
|
||||
"instances": [
|
||||
"2d295e897529",
|
||||
"3770bdb4bd34"
|
||||
]
|
||||
},
|
||||
"baseline": {
|
||||
"seconds": 8.002,
|
||||
"successful_requests": 935,
|
||||
"failed_requests": 0,
|
||||
"successful_rps": 116.844,
|
||||
"error_ratio": 0.0,
|
||||
"success_latency_ms": {
|
||||
"p50": 11.646,
|
||||
"p95": 97.063,
|
||||
"p99": 172.736
|
||||
},
|
||||
"instances": [
|
||||
"2d295e897529",
|
||||
"3770bdb4bd34"
|
||||
]
|
||||
},
|
||||
"failovers": [
|
||||
{
|
||||
"target": "2d295e897529",
|
||||
"stop_hook_exit": 0,
|
||||
"stop_hook_seconds": 3.727,
|
||||
"window": {
|
||||
"seconds": 9.727,
|
||||
"successful_requests": 579,
|
||||
"failed_requests": 23,
|
||||
"successful_rps": 59.525,
|
||||
"error_ratio": 0.038206,
|
||||
"success_latency_ms": {
|
||||
"p50": 84.219,
|
||||
"p95": 106.034,
|
||||
"p99": 186.674
|
||||
},
|
||||
"instances": [
|
||||
"2d295e897529",
|
||||
"3770bdb4bd34"
|
||||
]
|
||||
},
|
||||
"first_other_replica_success_seconds": 0.028,
|
||||
"target_seen_after_hook_returned": false,
|
||||
"instances_after_hook": [
|
||||
"3770bdb4bd34"
|
||||
],
|
||||
"restore_until_target_seen_seconds": 6.678,
|
||||
"instances_after_restore": [
|
||||
"2d295e897529",
|
||||
"3770bdb4bd34"
|
||||
],
|
||||
"restore_command_seconds": 7.205
|
||||
},
|
||||
{
|
||||
"target": "3770bdb4bd34",
|
||||
"stop_hook_exit": 0,
|
||||
"stop_hook_seconds": 3.676,
|
||||
"window": {
|
||||
"seconds": 9.677,
|
||||
"successful_requests": 618,
|
||||
"failed_requests": 67,
|
||||
"successful_rps": 63.866,
|
||||
"error_ratio": 0.09781,
|
||||
"success_latency_ms": {
|
||||
"p50": 80.567,
|
||||
"p95": 104.531,
|
||||
"p99": 186.578
|
||||
},
|
||||
"instances": [
|
||||
"2d295e897529",
|
||||
"3770bdb4bd34"
|
||||
]
|
||||
},
|
||||
"first_other_replica_success_seconds": 0.038,
|
||||
"target_seen_after_hook_returned": false,
|
||||
"instances_after_hook": [
|
||||
"2d295e897529"
|
||||
],
|
||||
"restore_until_target_seen_seconds": 5.856,
|
||||
"instances_after_restore": [
|
||||
"2d295e897529",
|
||||
"3770bdb4bd34"
|
||||
],
|
||||
"restore_command_seconds": 6.429
|
||||
}
|
||||
],
|
||||
"images_before_roll": [
|
||||
"sha256:677eedd39f22"
|
||||
],
|
||||
"images_after_roll": [
|
||||
"sha256:1de321e159c5"
|
||||
],
|
||||
"rolling_under_load": {
|
||||
"seconds": 25.247,
|
||||
"successful_requests": 2724,
|
||||
"failed_requests": 154,
|
||||
"successful_rps": 107.894,
|
||||
"error_ratio": 0.053509,
|
||||
"success_latency_ms": {
|
||||
"p50": 16.738,
|
||||
"p95": 99.468,
|
||||
"p99": 165.858
|
||||
},
|
||||
"instances": [
|
||||
"2d295e897529",
|
||||
"3770bdb4bd34",
|
||||
"3e683714be74",
|
||||
"43895eae9206"
|
||||
],
|
||||
"exit": 0,
|
||||
"stderr_tail": "f7 0.0s done\n#14 naming to docker.io/library/mtusi-messenger:lab3\n#14 naming to docker.io/library/mtusi-messenger:lab3 done\n#14 unpacking to docker.io/library/mtusi-messenger:lab3 0.0s done\n#14 DONE 0.2s\n Container mtusi-lab3-api-3 Running \n Container mtusi-lab3-api-4 Running \n Container mtusi-lab3-api-5 Creating \n Container mtusi-lab3-api-5 Created \n Container mtusi-lab3-api-5 Starting \n Container mtusi-lab3-api-5 Started \n Container mtusi-lab3-api-4 Running \n Container mtusi-lab3-api-5 Running \n Container mtusi-lab3-api-4 Running \n Container mtusi-lab3-api-5 Running \n Container mtusi-lab3-api-6 Creating \n Container mtusi-lab3-api-6 Created \n Container mtusi-lab3-api-6 Starting \n Container mtusi-lab3-api-6 Started \n Container mtusi-lab3-api-5 Running \n Container mtusi-lab3-api-6 Running \n"
|
||||
},
|
||||
"container_limits": [
|
||||
{
|
||||
"name": "mtusi-lab3-api-5",
|
||||
"nano_cpus": 500000000,
|
||||
"memory_bytes": 268435456,
|
||||
"published": "{\"8080/tcp\":null}"
|
||||
},
|
||||
{
|
||||
"name": "mtusi-lab3-api-6",
|
||||
"nano_cpus": 500000000,
|
||||
"memory_bytes": 268435456,
|
||||
"published": "{\"8080/tcp\":null}"
|
||||
},
|
||||
{
|
||||
"name": "mtusi-lab3-lb-1",
|
||||
"nano_cpus": 250000000,
|
||||
"memory_bytes": 134217728,
|
||||
"published": "{\"8080/tcp\":[{\"HostIp\":\"127.0.0.1\",\"HostPort\":\"8080\"}]}"
|
||||
},
|
||||
{
|
||||
"name": "mtusi-lab3-postgres-1",
|
||||
"nano_cpus": 750000000,
|
||||
"memory_bytes": 536870912,
|
||||
"published": "{\"5432/tcp\":null}"
|
||||
},
|
||||
{
|
||||
"name": "mtusi-lab3-valkey-1",
|
||||
"nano_cpus": 250000000,
|
||||
"memory_bytes": 134217728,
|
||||
"published": "{\"6379/tcp\":null}"
|
||||
}
|
||||
],
|
||||
"lb_timeouts": {
|
||||
"check_interval_seconds": 1,
|
||||
"unhealthy_after_failures": 1,
|
||||
"check_timeout_seconds": 1,
|
||||
"max_detection_seconds": 2,
|
||||
"connect_timeout_seconds": 1,
|
||||
"server_timeout_seconds": 8,
|
||||
"client_timeout_seconds": 8,
|
||||
"drain_seconds": 3,
|
||||
"stop_grace_seconds": 10
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
Дата: 2026-10-30
|
||||
Команда:
|
||||
|
||||
python3 tests/student_level4.py --base-url http://127.0.0.1:8080
|
||||
|
||||
PASS: level4 spread=2d295e897529,3770bdb4bd34 parallel_instances=2d295e897529,3770bdb4bd34
|
||||
|
||||
Одна сессия без повторного входа попала на две реплики: 2d295e897529 и 3770bdb4bd34.
|
||||
8 параллельных POST с одним Idempotency-Key и одним телом дали одно сообщение.
|
||||
Оба запроса дошли до разных реплик. Повтор с другим телом — 409.
|
||||
Одинаковый ключ у двух пользователей создал два разных сообщения.
|
||||
В истории чата этот текст встречается один раз.
|
||||
@@ -0,0 +1,19 @@
|
||||
Дата: 2026-10-30
|
||||
Команда:
|
||||
|
||||
python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080
|
||||
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
|
||||
scripts/restart.sh выполняет:
|
||||
docker compose --env-file .env -f compose.yaml restart api postgres valkey
|
||||
|
||||
Volumes не удалялись. После теста на месте:
|
||||
mtusi-lab3_pgdata
|
||||
mtusi-lab3_valkeydata
|
||||
|
||||
docker compose ps после hook: api-3 и api-4 Up (healthy), postgres Up (healthy), valkey Up (healthy).
|
||||
Контейнеры те же (CREATED не сброшен), процессы перезапущены (Up несколько секунд).
|
||||
Повторный migrate («migrations applied») не добавил вторую копию версии:
|
||||
001_init.sql — 1 строка, 002_idempotency.sql — 1 строка.
|
||||
@@ -0,0 +1,11 @@
|
||||
Дата: 2026-10-30
|
||||
Стенд: WSL Ubuntu 26.04, Docker 29.4.2, Compose 5.1.3, Python 3.14.4
|
||||
Команды:
|
||||
|
||||
python3 scripts/check_contract.py
|
||||
python3 tests/smoke.py --base-url http://127.0.0.1:8080
|
||||
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
|
||||
|
||||
Фраза application NOT tested — штатный текст offline-проверки: она не поднимает сервер. Живой API проверен smoke на http://127.0.0.1:8080. Контракт не менялся.
|
||||
@@ -0,0 +1,44 @@
|
||||
# Traefik 3.7.16. Без sticky cookie.
|
||||
# Адреса API Traefik берёт из Docker и обновляет по событиям start/die,
|
||||
# поэтому новая реплика и остановленная не зависят от кэша одного DNS-ответа.
|
||||
# Healthcheck: период 1s, timeout 1s, одна неуспешная проверка исключает backend.
|
||||
# Верхняя оценка обнаружения отказа: 1s до следующей проверки + 1s timeout = 2s.
|
||||
# Таймауты клиента и upstream согласованы с drain API (3s) и stop_grace_period (10s).
|
||||
|
||||
global:
|
||||
checkNewVersion: false
|
||||
sendAnonymousUsage: false
|
||||
|
||||
entryPoints:
|
||||
web:
|
||||
address: ":8080"
|
||||
http:
|
||||
aliasHeadersStrategy: reject
|
||||
transport:
|
||||
respondingTimeouts:
|
||||
readTimeout: 8s
|
||||
writeTimeout: 8s
|
||||
idleTimeout: 5s
|
||||
ping:
|
||||
address: "127.0.0.1:8082"
|
||||
http:
|
||||
aliasHeadersStrategy: delete
|
||||
|
||||
ping:
|
||||
entryPoint: ping
|
||||
|
||||
providers:
|
||||
docker:
|
||||
endpoint: unix:///var/run/docker.sock
|
||||
exposedByDefault: false
|
||||
network: mtusi-lab3-net
|
||||
watch: true
|
||||
|
||||
serversTransport:
|
||||
forwardingTimeouts:
|
||||
dialTimeout: 1s
|
||||
responseHeaderTimeout: 8s
|
||||
idleConnTimeout: 1s
|
||||
|
||||
log:
|
||||
level: INFO
|
||||
@@ -0,0 +1,49 @@
|
||||
-- Пользователи, чаты, участники, сообщения.
|
||||
-- Сессии здесь не хранятся: их источник истины — Valkey (AOF + volume).
|
||||
-- Идемпотентность отправки — в 002_idempotency.sql.
|
||||
--
|
||||
-- Транзакции приложения:
|
||||
-- регистрация — один INSERT, уникальность username держит UNIQUE
|
||||
-- создание чата — одна транзакция: чат и все chat_members, иначе откат
|
||||
-- сообщение и запись идемпотентности — одна транзакция
|
||||
--
|
||||
-- Индекс истории messages_history_idx покрывает keyset-запрос
|
||||
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
-- ORDER BY created_at, id
|
||||
-- LIMIT $4
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT users_username_unique UNIQUE (username)
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX chats_created_idx ON chats (created_at, id);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
position integer NOT NULL,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_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 text NOT NULL,
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,18 @@
|
||||
-- Общий результат POST сообщения.
|
||||
-- Область: user_id + http_method + path + idem_key.
|
||||
-- Строка пишется в той же транзакции, что и messages, поэтому 5xx
|
||||
-- до COMMIT не оставляет ни сообщения, ни «окончательного» ключа.
|
||||
-- Повтор с другим request_hash в пределах TTL — отказ без второй вставки.
|
||||
|
||||
CREATE TABLE idempotency_keys (
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
http_method text NOT NULL,
|
||||
path text NOT NULL,
|
||||
idem_key text NOT NULL,
|
||||
request_hash text NOT NULL,
|
||||
message_id uuid NOT NULL REFERENCES messages (id),
|
||||
created_at timestamptz NOT NULL,
|
||||
PRIMARY KEY (user_id, http_method, path, idem_key)
|
||||
);
|
||||
|
||||
CREATE INDEX idempotency_keys_created_idx ON idempotency_keys (created_at);
|
||||
@@ -0,0 +1,3 @@
|
||||
psycopg[binary]==3.2.3
|
||||
psycopg-pool==3.2.3
|
||||
redis==5.1.1
|
||||
@@ -0,0 +1,325 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Нагрузка, поочерёдный отказ каждой реплики и rolling update. Токены не печатает."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import platform
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "tests"))
|
||||
|
||||
from client import Client, Failure # noqa: E402
|
||||
|
||||
|
||||
def run(cmd, env=None, check=True):
|
||||
return subprocess.run(
|
||||
cmd,
|
||||
cwd=ROOT,
|
||||
env=env,
|
||||
check=check,
|
||||
text=True,
|
||||
capture_output=True,
|
||||
)
|
||||
|
||||
|
||||
def compose(*args):
|
||||
return run(["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", *args])
|
||||
|
||||
|
||||
def api_ids():
|
||||
proc = compose("ps", "-q", "api")
|
||||
return [line.strip() for line in proc.stdout.splitlines() if line.strip()]
|
||||
|
||||
|
||||
def inspect(cid, fmt):
|
||||
return run(["docker", "inspect", "-f", fmt, cid]).stdout.strip()
|
||||
|
||||
|
||||
def percentile(values, p):
|
||||
if not values:
|
||||
return None
|
||||
ordered = sorted(values)
|
||||
index = max(0, int(round((len(ordered) - 1) * p)))
|
||||
return round(ordered[index] * 1000, 3)
|
||||
|
||||
|
||||
class Load:
|
||||
def __init__(self, base, actor, chat, concurrency=4):
|
||||
self.base = base
|
||||
self.actor = actor
|
||||
self.chat = chat
|
||||
self.concurrency = concurrency
|
||||
self.events = []
|
||||
self._stop = threading.Event()
|
||||
self._origin = time.monotonic()
|
||||
self._pool = None
|
||||
self._futures = []
|
||||
|
||||
def now(self):
|
||||
return time.monotonic() - self._origin
|
||||
|
||||
def start(self):
|
||||
def worker(worker_id):
|
||||
local = Client(self.base, timeout=3)
|
||||
index = 0
|
||||
while not self._stop.is_set():
|
||||
stamp = self.now()
|
||||
try:
|
||||
response = local.message(
|
||||
self.actor,
|
||||
self.chat,
|
||||
"load-%s-%s-%s" % (worker_id, index, uuid.uuid4().hex[:8]),
|
||||
)
|
||||
self.events.append({
|
||||
"ok": True,
|
||||
"t": stamp,
|
||||
"dt": self.now() - stamp,
|
||||
"instance": response["headers"].get("X-Instance-Id"),
|
||||
})
|
||||
except Failure:
|
||||
self.events.append({
|
||||
"ok": False,
|
||||
"t": stamp,
|
||||
"dt": self.now() - stamp,
|
||||
"instance": None,
|
||||
})
|
||||
index += 1
|
||||
|
||||
self._pool = ThreadPoolExecutor(max_workers=self.concurrency)
|
||||
self._futures = [self._pool.submit(worker, i) for i in range(self.concurrency)]
|
||||
|
||||
def stop(self):
|
||||
self._stop.set()
|
||||
for future in self._futures:
|
||||
future.result()
|
||||
self._pool.shutdown(wait=True)
|
||||
|
||||
def summary(self, start, end):
|
||||
window = [item for item in self.events if start <= item["t"] < end]
|
||||
ok = [item for item in window if item["ok"]]
|
||||
bad = [item for item in window if not item["ok"]]
|
||||
elapsed = max(end - start, 0.001)
|
||||
return {
|
||||
"seconds": round(end - start, 3),
|
||||
"successful_requests": len(ok),
|
||||
"failed_requests": len(bad),
|
||||
"successful_rps": round(len(ok) / elapsed, 3),
|
||||
"error_ratio": round(len(bad) / len(window), 6) if window else None,
|
||||
"success_latency_ms": {
|
||||
"p50": percentile([item["dt"] for item in ok], 0.50),
|
||||
"p95": percentile([item["dt"] for item in ok], 0.95),
|
||||
"p99": percentile([item["dt"] for item in ok], 0.99),
|
||||
},
|
||||
"instances": sorted({item["instance"] for item in ok if item["instance"]}),
|
||||
}
|
||||
|
||||
|
||||
def wait_ready(base, timeout=90):
|
||||
deadline = time.monotonic() + timeout
|
||||
while True:
|
||||
try:
|
||||
Client(base, timeout=2).call("GET", "/health/ready", schema="Health")
|
||||
return
|
||||
except Failure:
|
||||
if time.monotonic() > deadline:
|
||||
raise SystemExit("API did not become ready")
|
||||
time.sleep(0.5)
|
||||
|
||||
|
||||
def wait_instance(base, actor, wanted, timeout):
|
||||
started = time.monotonic()
|
||||
seen = set()
|
||||
while time.monotonic() - started < timeout:
|
||||
try:
|
||||
seen.add(
|
||||
Client(base, timeout=2).call(
|
||||
"GET", "/api/v1/users/me", actor=actor, schema="User"
|
||||
)["headers"]["X-Instance-Id"]
|
||||
)
|
||||
except Failure:
|
||||
pass
|
||||
if wanted in seen:
|
||||
return round(time.monotonic() - started, 3), sorted(seen)
|
||||
time.sleep(0.2)
|
||||
return None, sorted(seen)
|
||||
|
||||
|
||||
def container_limits():
|
||||
rows = []
|
||||
proc = compose("ps", "-q")
|
||||
for cid in [line.strip() for line in proc.stdout.splitlines() if line.strip()]:
|
||||
rows.append({
|
||||
"name": inspect(cid, "{{.Name}}").lstrip("/"),
|
||||
"nano_cpus": int(inspect(cid, "{{.HostConfig.NanoCpus}}") or "0"),
|
||||
"memory_bytes": int(inspect(cid, "{{.HostConfig.Memory}}") or "0"),
|
||||
"published": inspect(cid, "{{json .NetworkSettings.Ports}}"),
|
||||
})
|
||||
return rows
|
||||
|
||||
|
||||
def main():
|
||||
base = os.environ.get("BASE_URL", "http://localhost:8080")
|
||||
wait_ready(base)
|
||||
client = Client(base, timeout=10)
|
||||
alice, _bob, _eve, chat = client.bootstrap()
|
||||
spread = [
|
||||
client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"]
|
||||
for _ in range(30)
|
||||
]
|
||||
observed = sorted(set(spread))
|
||||
if len(observed) < 2:
|
||||
raise SystemExit("need two instance ids, saw %s" % observed)
|
||||
|
||||
key = "probe-" + uuid.uuid4().hex
|
||||
text = "параллельный ключ " + key
|
||||
barrier = threading.Barrier(8)
|
||||
|
||||
def once(_n):
|
||||
local = Client(base, timeout=10)
|
||||
barrier.wait()
|
||||
response = local.message(alice, chat, text, key=key)
|
||||
return response["json"]["id"], response["headers"]["X-Instance-Id"]
|
||||
|
||||
with ThreadPoolExecutor(max_workers=8) as pool:
|
||||
parallel = list(pool.map(once, range(8)))
|
||||
parallel_ids = sorted({item[0] for item in parallel})
|
||||
parallel_instances = sorted({item[1] for item in parallel})
|
||||
if len(parallel_ids) != 1:
|
||||
raise SystemExit("parallel idempotency created %s messages" % len(parallel_ids))
|
||||
|
||||
load = Load(base, alice, chat)
|
||||
load.start()
|
||||
time.sleep(8)
|
||||
baseline_end = load.now()
|
||||
baseline = load.summary(0, baseline_end)
|
||||
|
||||
failovers = []
|
||||
for target in observed:
|
||||
time.sleep(1)
|
||||
mark = load.now()
|
||||
env = os.environ.copy()
|
||||
env["TARGET_INSTANCE_ID"] = target
|
||||
started = time.monotonic()
|
||||
proc = run([str(ROOT / "scripts" / "stop-one.sh")], env=env, check=False)
|
||||
stop_s = round(time.monotonic() - started, 3)
|
||||
stopped_at = load.now()
|
||||
time.sleep(6)
|
||||
window_end = load.now()
|
||||
after = [item for item in load.events if item["t"] >= stopped_at and item["ok"]]
|
||||
served = sorted({item["instance"] for item in after if item["instance"]})
|
||||
first = None
|
||||
for item in load.events:
|
||||
if item["t"] >= mark and item["ok"] and item["instance"] and item["instance"] != target:
|
||||
first = round(item["t"] - mark, 3)
|
||||
break
|
||||
restore_started = time.monotonic()
|
||||
run([str(ROOT / "scripts" / "restore-api.sh")])
|
||||
back_s, seen_after = wait_instance(base, alice, target, 40)
|
||||
failovers.append({
|
||||
"target": target,
|
||||
"stop_hook_exit": proc.returncode,
|
||||
"stop_hook_seconds": stop_s,
|
||||
"window": load.summary(mark, window_end),
|
||||
"first_other_replica_success_seconds": first,
|
||||
"target_seen_after_hook_returned": target in served,
|
||||
"instances_after_hook": served,
|
||||
"restore_until_target_seen_seconds": back_s,
|
||||
"instances_after_restore": seen_after,
|
||||
"restore_command_seconds": round(time.monotonic() - restore_started, 3),
|
||||
})
|
||||
if proc.returncode != 0:
|
||||
load.stop()
|
||||
raise SystemExit("stop-one failed for %s\n%s" % (target, proc.stderr))
|
||||
if first is None or first > 10 or target in served:
|
||||
load.stop()
|
||||
raise SystemExit("failover criteria failed for %s" % target)
|
||||
|
||||
images_before = sorted({inspect(cid, "{{.Image}}")[:19] for cid in api_ids()})
|
||||
roll_mark = load.now()
|
||||
holder = {}
|
||||
|
||||
def run_roll():
|
||||
proc = run([str(ROOT / "scripts" / "rolling-update.sh")], check=False)
|
||||
holder["code"] = proc.returncode
|
||||
holder["err"] = (proc.stderr or "")[-800:]
|
||||
holder["out"] = (proc.stdout or "")[-800:]
|
||||
|
||||
roller = threading.Thread(target=run_roll)
|
||||
roller.start()
|
||||
roller.join()
|
||||
roll_end = load.now()
|
||||
load.stop()
|
||||
images_after = sorted({inspect(cid, "{{.Image}}")[:19] for cid in api_ids()})
|
||||
rolling = load.summary(roll_mark, roll_end)
|
||||
rolling["exit"] = holder.get("code")
|
||||
rolling["stderr_tail"] = holder.get("err")
|
||||
if holder.get("code") != 0:
|
||||
raise SystemExit("rolling update failed: %s\n%s" % (holder.get("err"), holder.get("out")))
|
||||
|
||||
report = {
|
||||
"date": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
|
||||
"platform": platform.platform(),
|
||||
"cpu_count": os.cpu_count(),
|
||||
"workload": "closed-loop POST, concurrency 4, client timeout 3s, no client retry",
|
||||
"observed_instances": observed,
|
||||
"parallel_idempotency": {
|
||||
"requests": 8,
|
||||
"unique_message_ids": len(parallel_ids),
|
||||
"instances": parallel_instances,
|
||||
},
|
||||
"baseline": baseline,
|
||||
"failovers": failovers,
|
||||
"images_before_roll": images_before,
|
||||
"images_after_roll": images_after,
|
||||
"rolling_under_load": rolling,
|
||||
"container_limits": container_limits(),
|
||||
"lb_timeouts": {
|
||||
"check_interval_seconds": 1,
|
||||
"unhealthy_after_failures": 1,
|
||||
"check_timeout_seconds": 1,
|
||||
"max_detection_seconds": 2,
|
||||
"connect_timeout_seconds": 1,
|
||||
"server_timeout_seconds": 8,
|
||||
"client_timeout_seconds": 8,
|
||||
"drain_seconds": 3,
|
||||
"stop_grace_seconds": 10,
|
||||
},
|
||||
}
|
||||
dest = ROOT / "evidence" / "grade4.json"
|
||||
dest.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
||||
print(json.dumps({
|
||||
"observed_instances": observed,
|
||||
"parallel_unique_messages": len(parallel_ids),
|
||||
"parallel_instances": parallel_instances,
|
||||
"baseline_rps": baseline["successful_rps"],
|
||||
"baseline_errors": baseline["failed_requests"],
|
||||
"failovers": [
|
||||
{
|
||||
"target": item["target"],
|
||||
"stop_s": item["stop_hook_seconds"],
|
||||
"first_other_s": item["first_other_replica_success_seconds"],
|
||||
"errors": item["window"]["failed_requests"],
|
||||
"rps": item["window"]["successful_rps"],
|
||||
"target_seen_after_hook": item["target_seen_after_hook_returned"],
|
||||
"restore_s": item["restore_until_target_seen_seconds"],
|
||||
}
|
||||
for item in failovers
|
||||
],
|
||||
"rolling_exit": rolling["exit"],
|
||||
"rolling_errors": rolling["failed_requests"],
|
||||
"rolling_rps": rolling["successful_rps"],
|
||||
"images_changed": images_before != images_after,
|
||||
"evidence": "evidence/grade4.json",
|
||||
}, ensure_ascii=False, indent=2))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
# Перезапуск API и хранилищ. Volumes не удаляются, схема и данные остаются.
|
||||
docker compose --env-file .env -f compose.yaml restart api postgres valkey
|
||||
@@ -0,0 +1,8 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
replicas=$(sed -n 's/^API_REPLICAS=//p' .env | tr -d '\r')
|
||||
if [ -z "${replicas}" ]; then
|
||||
replicas=2
|
||||
fi
|
||||
docker compose --env-file .env -f compose.yaml up -d --no-deps --scale "api=${replicas}" --no-recreate api
|
||||
@@ -0,0 +1,56 @@
|
||||
#!/bin/sh
|
||||
# Поочерёдная замена API: сначала поднимается новая реплика, затем останавливается старая.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
compose() {
|
||||
docker compose --env-file .env -f compose.yaml "$@"
|
||||
}
|
||||
|
||||
bid=$(date +%s)
|
||||
docker build --build-arg "BUILD_ID=${bid}" -t mtusi-messenger:lab3 .
|
||||
|
||||
old=$(compose ps -q api)
|
||||
if [ -z "$old" ]; then
|
||||
echo "no running api replicas" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
healthy_count() {
|
||||
n=0
|
||||
for id in $(compose ps -q api); do
|
||||
status=$(docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' "$id")
|
||||
if [ "$status" = "healthy" ]; then
|
||||
n=$((n + 1))
|
||||
fi
|
||||
done
|
||||
printf '%s' "$n"
|
||||
}
|
||||
|
||||
wait_healthy() {
|
||||
want=$1
|
||||
i=0
|
||||
while [ "$i" -lt 45 ]; do
|
||||
n=$(healthy_count)
|
||||
if [ "$n" -ge "$want" ]; then
|
||||
return 0
|
||||
fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
echo "wanted ${want} healthy api, saw $(healthy_count)" >&2
|
||||
return 1
|
||||
}
|
||||
|
||||
for cid in $old; do
|
||||
echo "replacement before stop ${cid}"
|
||||
compose up -d --no-deps --scale api=3 --no-recreate api
|
||||
wait_healthy 3
|
||||
docker stop -t 8 "$cid" >/dev/null
|
||||
docker rm "$cid" >/dev/null
|
||||
compose up -d --no-deps --scale api=2 --no-recreate api
|
||||
wait_healthy 2
|
||||
done
|
||||
|
||||
echo "rolling update done"
|
||||
compose ps api
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}"
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
found=""
|
||||
for cid in $(docker compose --env-file .env -f compose.yaml ps -q api); do
|
||||
host=$(docker inspect -f '{{.Config.Hostname}}' "$cid")
|
||||
short=$(printf '%s' "$cid" | cut -c1-12)
|
||||
if [ "$host" = "$TARGET_INSTANCE_ID" ] || [ "$short" = "$TARGET_INSTANCE_ID" ]; then
|
||||
found=$cid
|
||||
break
|
||||
fi
|
||||
done
|
||||
|
||||
if [ -z "$found" ]; then
|
||||
echo "API replica was not found" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# docker stop + restart: unless-stopped оставляет реплику выключенной.
|
||||
docker stop -t 8 "$found" >/dev/null
|
||||
@@ -0,0 +1,12 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
if [ ! -f .env ]; then
|
||||
echo "Copy .env.example to .env" >&2
|
||||
exit 1
|
||||
fi
|
||||
replicas=$(sed -n 's/^API_REPLICAS=//p' .env | tr -d '\r')
|
||||
if [ -z "${replicas}" ]; then
|
||||
replicas=2
|
||||
fi
|
||||
docker compose --env-file .env -f compose.yaml up -d --build --scale "api=${replicas}" --remove-orphans
|
||||
@@ -0,0 +1,451 @@
|
||||
"""PostgreSQL: пользователи, чаты, участники, сообщения, идемпотентность."""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import contextmanager
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import psycopg
|
||||
from psycopg.errors import UniqueViolation
|
||||
from psycopg_pool import ConnectionPool, PoolTimeout
|
||||
|
||||
from errors import ApiError
|
||||
|
||||
_pool: ConnectionPool | None = None
|
||||
|
||||
|
||||
def migrations_dir() -> Path:
|
||||
here = Path(__file__).resolve().parent
|
||||
for candidate in (here / "migrations", here.parent / "migrations"):
|
||||
if candidate.is_dir():
|
||||
return candidate
|
||||
return here.parent / "migrations"
|
||||
|
||||
|
||||
def database_url() -> str:
|
||||
path = os.environ.get("DATABASE_URL_FILE", "").strip()
|
||||
if path and Path(path).is_file():
|
||||
return Path(path).read_text(encoding="utf-8").strip()
|
||||
return os.environ.get("DATABASE_URL", "").strip()
|
||||
|
||||
|
||||
def idempotency_ttl() -> int:
|
||||
raw = os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400")
|
||||
try:
|
||||
value = int(raw)
|
||||
except ValueError:
|
||||
return 86400
|
||||
return value if value >= 1 else 86400
|
||||
|
||||
|
||||
def init() -> None:
|
||||
global _pool
|
||||
url = database_url()
|
||||
if not url:
|
||||
raise RuntimeError("database is not configured")
|
||||
_pool = ConnectionPool(
|
||||
url,
|
||||
min_size=0,
|
||||
max_size=12,
|
||||
timeout=3,
|
||||
open=True,
|
||||
kwargs={
|
||||
"connect_timeout": 3,
|
||||
"autocommit": False,
|
||||
"options": "-c statement_timeout=5000",
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def migrate_with_retry() -> None:
|
||||
last = None
|
||||
for _ in range(30):
|
||||
try:
|
||||
migrate()
|
||||
return
|
||||
except Exception as exc:
|
||||
last = exc
|
||||
time.sleep(1)
|
||||
raise RuntimeError("migrations failed") from last
|
||||
|
||||
|
||||
def migrate() -> None:
|
||||
url = database_url()
|
||||
if not url:
|
||||
raise RuntimeError("database is not configured")
|
||||
with psycopg.connect(url, connect_timeout=3, autocommit=False) as conn:
|
||||
conn.execute("SELECT pg_advisory_lock(%s)", (842021,))
|
||||
conn.execute(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
)
|
||||
"""
|
||||
)
|
||||
conn.commit()
|
||||
applied = {
|
||||
row[0]
|
||||
for row in conn.execute("SELECT version FROM schema_migrations").fetchall()
|
||||
}
|
||||
for path in sorted(migrations_dir().glob("*.sql")):
|
||||
if path.name in applied:
|
||||
continue
|
||||
sql = path.read_text(encoding="utf-8")
|
||||
with conn.transaction():
|
||||
for statement in sql.split(";"):
|
||||
if statement.strip():
|
||||
conn.execute(statement)
|
||||
conn.execute(
|
||||
"INSERT INTO schema_migrations (version) VALUES (%s)",
|
||||
(path.name,),
|
||||
)
|
||||
|
||||
|
||||
@contextmanager
|
||||
def connection():
|
||||
if _pool is None:
|
||||
raise ApiError(503, "unavailable", "База данных недоступна")
|
||||
try:
|
||||
with _pool.connection() as conn:
|
||||
yield conn
|
||||
except ApiError:
|
||||
raise
|
||||
except (PoolTimeout, psycopg.OperationalError, psycopg.InterfaceError) as exc:
|
||||
raise ApiError(503, "unavailable", "База данных недоступна") from exc
|
||||
|
||||
|
||||
def ping() -> bool:
|
||||
try:
|
||||
with connection() as conn:
|
||||
conn.execute("SELECT 1")
|
||||
return True
|
||||
except ApiError:
|
||||
return False
|
||||
|
||||
|
||||
def close() -> None:
|
||||
if _pool is not None:
|
||||
_pool.close()
|
||||
|
||||
|
||||
def user_json(row) -> dict:
|
||||
return {
|
||||
"id": str(row[0]),
|
||||
"username": row[1],
|
||||
"display_name": row[2],
|
||||
"created_at": format_ts(row[3]),
|
||||
}
|
||||
|
||||
|
||||
def format_ts(value: datetime) -> str:
|
||||
value = value.astimezone(timezone.utc)
|
||||
return value.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
|
||||
|
||||
|
||||
def create_user(username: str, display_name: str, password_hash: str, created: datetime) -> dict:
|
||||
uid = uuid.uuid4()
|
||||
try:
|
||||
with connection() as conn:
|
||||
with conn.transaction():
|
||||
row = conn.execute(
|
||||
"""
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (%s, %s, %s, %s, %s)
|
||||
RETURNING id, username, display_name, created_at
|
||||
""",
|
||||
(uid, username, display_name, password_hash, created),
|
||||
).fetchone()
|
||||
except UniqueViolation as exc:
|
||||
raise ApiError(409, "conflict", "username занят") from exc
|
||||
return user_json(row)
|
||||
|
||||
|
||||
def user_for_login(username: str):
|
||||
with connection() as conn:
|
||||
return conn.execute(
|
||||
"""
|
||||
SELECT id, username, display_name, password_hash, created_at
|
||||
FROM users
|
||||
WHERE username = %s
|
||||
""",
|
||||
(username,),
|
||||
).fetchone()
|
||||
|
||||
|
||||
def get_user(user_id: str) -> dict | None:
|
||||
with connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, username, display_name, created_at
|
||||
FROM users
|
||||
WHERE id = %s
|
||||
""",
|
||||
(uuid.UUID(user_id),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
return user_json(row)
|
||||
|
||||
|
||||
def create_chat(title: str, member_ids: list[str], created: datetime) -> dict:
|
||||
cid = uuid.uuid4()
|
||||
members = [uuid.UUID(item) for item in member_ids]
|
||||
with connection() as conn:
|
||||
with conn.transaction():
|
||||
conn.execute(
|
||||
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
|
||||
(cid, title, created),
|
||||
)
|
||||
found = conn.execute(
|
||||
"SELECT id FROM users WHERE id = ANY(%s::uuid[])",
|
||||
(members,),
|
||||
).fetchall()
|
||||
if {row[0] for row in found} != set(members):
|
||||
raise ApiError(400, "invalid_request", "неизвестный участник")
|
||||
for position, member in enumerate(members):
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO chat_members (chat_id, user_id, position)
|
||||
VALUES (%s, %s, %s)
|
||||
""",
|
||||
(cid, member, position),
|
||||
)
|
||||
return {
|
||||
"id": str(cid),
|
||||
"title": title,
|
||||
"member_ids": list(member_ids),
|
||||
"created_at": format_ts(created),
|
||||
}
|
||||
|
||||
|
||||
def _chat_row(row) -> dict:
|
||||
return {
|
||||
"id": str(row[0]),
|
||||
"title": row[1],
|
||||
"created_at": format_ts(row[2]),
|
||||
"member_ids": [str(item) for item in row[3]],
|
||||
}
|
||||
|
||||
|
||||
def get_chat(chat_id: str, user_id: str) -> dict:
|
||||
with connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT c.id, c.title, c.created_at,
|
||||
array_agg(cm.user_id ORDER BY cm.position)
|
||||
FROM chats c
|
||||
JOIN chat_members mine
|
||||
ON mine.chat_id = c.id AND mine.user_id = %s
|
||||
JOIN chat_members cm ON cm.chat_id = c.id
|
||||
WHERE c.id = %s
|
||||
GROUP BY c.id
|
||||
""",
|
||||
(uuid.UUID(user_id), uuid.UUID(chat_id)),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise ApiError(404, "not_found", "Чат не найден")
|
||||
chat = _chat_row(row)
|
||||
return {
|
||||
"id": chat["id"],
|
||||
"title": chat["title"],
|
||||
"member_ids": chat["member_ids"],
|
||||
"created_at": chat["created_at"],
|
||||
}
|
||||
|
||||
|
||||
def list_chats(user_id: str, limit: int, cursor) -> dict:
|
||||
params: list = [uuid.UUID(user_id)]
|
||||
where = ""
|
||||
if cursor is not None:
|
||||
created, chat_id = cursor
|
||||
where = "WHERE (c.created_at, c.id) > (%s, %s)"
|
||||
params.extend([created, uuid.UUID(chat_id)])
|
||||
params.append(limit + 1)
|
||||
sql = f"""
|
||||
SELECT c.id, c.title, c.created_at,
|
||||
array_agg(cm.user_id ORDER BY cm.position)
|
||||
FROM chats c
|
||||
JOIN chat_members mine
|
||||
ON mine.chat_id = c.id AND mine.user_id = %s
|
||||
JOIN chat_members cm ON cm.chat_id = c.id
|
||||
{where}
|
||||
GROUP BY c.id
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT %s
|
||||
"""
|
||||
with connection() as conn:
|
||||
rows = conn.execute(sql, params).fetchall()
|
||||
page = rows[:limit]
|
||||
next_cursor = None
|
||||
if len(rows) > limit and page:
|
||||
last = page[-1]
|
||||
next_cursor = (last[2], str(last[0]))
|
||||
return {
|
||||
"items": [
|
||||
{
|
||||
"id": str(row[0]),
|
||||
"title": row[1],
|
||||
"member_ids": [str(item) for item in row[3]],
|
||||
"created_at": format_ts(row[2]),
|
||||
}
|
||||
for row in page
|
||||
],
|
||||
"next_cursor_parts": next_cursor,
|
||||
}
|
||||
|
||||
|
||||
def _lock_key(scope: str) -> int:
|
||||
digest = hashlib.sha256(scope.encode("utf-8")).digest()
|
||||
return int.from_bytes(digest[:8], "big", signed=True)
|
||||
|
||||
|
||||
def _is_member(conn, chat_id: str, user_id: str) -> bool:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT 1 FROM chat_members
|
||||
WHERE chat_id = %s AND user_id = %s
|
||||
""",
|
||||
(uuid.UUID(chat_id), uuid.UUID(user_id)),
|
||||
).fetchone()
|
||||
return row is not None
|
||||
|
||||
|
||||
def _load_message(conn, message_id) -> dict:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE id = %s
|
||||
""",
|
||||
(message_id,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise ApiError(500, "internal_error", "Внутренняя ошибка")
|
||||
return message_json(row)
|
||||
|
||||
|
||||
def create_message_idempotent(
|
||||
chat_id: str,
|
||||
sender_id: str,
|
||||
text: str,
|
||||
created: datetime,
|
||||
method: str,
|
||||
path: str,
|
||||
idem_key: str,
|
||||
request_hash: str,
|
||||
) -> dict:
|
||||
"""Один ключ — одно сообщение, в том числе при гонке двух реплик.
|
||||
|
||||
pg_advisory_xact_lock сериализует одинаковую область.
|
||||
INSERT сообщения и INSERT ключа коммитятся вместе.
|
||||
"""
|
||||
scope = "%s|%s|%s|%s" % (sender_id, method, path, idem_key)
|
||||
ttl = idempotency_ttl()
|
||||
with connection() as conn:
|
||||
with conn.transaction():
|
||||
conn.execute("SELECT pg_advisory_xact_lock(%s::bigint)", (_lock_key(scope),))
|
||||
existing = conn.execute(
|
||||
"""
|
||||
SELECT request_hash, message_id, created_at
|
||||
FROM idempotency_keys
|
||||
WHERE user_id = %s AND http_method = %s AND path = %s AND idem_key = %s
|
||||
""",
|
||||
(uuid.UUID(sender_id), method, path, idem_key),
|
||||
).fetchone()
|
||||
if existing is not None:
|
||||
age = conn.execute("SELECT now()").fetchone()[0] - existing[2]
|
||||
if age.total_seconds() > ttl:
|
||||
conn.execute(
|
||||
"""
|
||||
DELETE FROM idempotency_keys
|
||||
WHERE user_id = %s AND http_method = %s AND path = %s AND idem_key = %s
|
||||
""",
|
||||
(uuid.UUID(sender_id), method, path, idem_key),
|
||||
)
|
||||
existing = None
|
||||
if existing is not None:
|
||||
if existing[0] != request_hash:
|
||||
raise ApiError(409, "conflict", "повторный ключ с другим сообщением")
|
||||
if not _is_member(conn, chat_id, sender_id):
|
||||
raise ApiError(404, "not_found", "Чат не найден")
|
||||
return _load_message(conn, existing[1])
|
||||
if not _is_member(conn, chat_id, sender_id):
|
||||
raise ApiError(404, "not_found", "Чат не найден")
|
||||
mid = uuid.uuid4()
|
||||
row = conn.execute(
|
||||
"""
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES (%s, %s, %s, %s, %s)
|
||||
RETURNING id, chat_id, sender_id, text, created_at
|
||||
""",
|
||||
(mid, uuid.UUID(chat_id), uuid.UUID(sender_id), text, created),
|
||||
).fetchone()
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO idempotency_keys (
|
||||
user_id, http_method, path, idem_key, request_hash, message_id, created_at
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s)
|
||||
""",
|
||||
(uuid.UUID(sender_id), method, path, idem_key, request_hash, mid, created),
|
||||
)
|
||||
return message_json(row)
|
||||
|
||||
|
||||
def list_messages(chat_id: str, user_id: str, limit: int, cursor) -> dict:
|
||||
params: list = [uuid.UUID(chat_id), uuid.UUID(chat_id), uuid.UUID(user_id)]
|
||||
cursor_sql = ""
|
||||
if cursor is not None:
|
||||
created, message_id = cursor
|
||||
cursor_sql = "AND (m.created_at, m.id) > (%s, %s)"
|
||||
params.extend([created, uuid.UUID(message_id)])
|
||||
params.append(limit + 1)
|
||||
sql = f"""
|
||||
SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at
|
||||
FROM messages m
|
||||
WHERE m.chat_id = %s
|
||||
AND EXISTS (
|
||||
SELECT 1 FROM chat_members
|
||||
WHERE chat_id = %s AND user_id = %s
|
||||
)
|
||||
{cursor_sql}
|
||||
ORDER BY m.created_at, m.id
|
||||
LIMIT %s
|
||||
"""
|
||||
with connection() as conn:
|
||||
rows = conn.execute(sql, params).fetchall()
|
||||
if not rows:
|
||||
with connection() as conn:
|
||||
member = conn.execute(
|
||||
"""
|
||||
SELECT 1 FROM chat_members
|
||||
WHERE chat_id = %s AND user_id = %s
|
||||
""",
|
||||
(uuid.UUID(chat_id), uuid.UUID(user_id)),
|
||||
).fetchone()
|
||||
if member is None:
|
||||
raise ApiError(404, "not_found", "Чат не найден")
|
||||
page = rows[:limit]
|
||||
next_cursor = None
|
||||
if len(rows) > limit and page:
|
||||
last = page[-1]
|
||||
next_cursor = (last[4], str(last[0]))
|
||||
return {
|
||||
"items": [message_json(row) for row in page],
|
||||
"next_cursor_parts": next_cursor,
|
||||
}
|
||||
|
||||
|
||||
def message_json(row) -> dict:
|
||||
return {
|
||||
"id": str(row[0]),
|
||||
"chat_id": str(row[1]),
|
||||
"sender_id": str(row[2]),
|
||||
"text": row[3],
|
||||
"created_at": format_ts(row[4]),
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
"""Ошибки API. Текст не содержит SQL, паролей и токенов."""
|
||||
|
||||
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status: int, code: str, message: str):
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
@@ -0,0 +1,14 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Однократные миграции. Реплики API этот файл не запускают."""
|
||||
import sys
|
||||
|
||||
import db
|
||||
|
||||
|
||||
def main() -> None:
|
||||
db.migrate_with_retry()
|
||||
sys.stderr.write("migrations applied\n")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,43 @@
|
||||
"""Пароли: scrypt из hashlib. Не bcrypt — он режет пароль на 72 байтах."""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import secrets
|
||||
|
||||
N = 2**14
|
||||
R = 8
|
||||
P = 1
|
||||
DKLEN = 32
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
salt = secrets.token_bytes(16)
|
||||
digest = hashlib.scrypt(
|
||||
password.encode("utf-8"), salt=salt, n=N, r=R, p=P, dklen=DKLEN,
|
||||
maxmem=64 * 1024 * 1024)
|
||||
return "scrypt$%d$%d$%d$%s$%s" % (
|
||||
N, R, P,
|
||||
base64.b64encode(salt).decode("ascii"),
|
||||
base64.b64encode(digest).decode("ascii"),
|
||||
)
|
||||
|
||||
|
||||
def verify_password(password: str, stored: str) -> bool:
|
||||
try:
|
||||
algo, n, r, p, salt_b64, digest_b64 = stored.split("$")
|
||||
if algo != "scrypt":
|
||||
return False
|
||||
salt = base64.b64decode(salt_b64)
|
||||
expected = base64.b64decode(digest_b64)
|
||||
actual = hashlib.scrypt(
|
||||
password.encode("utf-8"), salt=salt, n=int(n), r=int(r), p=int(p),
|
||||
dklen=len(expected), maxmem=64 * 1024 * 1024)
|
||||
except (ValueError, TypeError):
|
||||
return False
|
||||
return hmac.compare_digest(actual, expected)
|
||||
|
||||
|
||||
# Одинаковая стоимость проверки, когда пользователя нет.
|
||||
DUMMY_HASH = hash_password("dummy-password-not-used")
|
||||
+543
@@ -0,0 +1,543 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Messenger lab3. Общие PostgreSQL и Valkey, несколько реплик за Traefik."""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import signal
|
||||
import socket
|
||||
import socketserver
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from http.server import BaseHTTPRequestHandler
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
import db
|
||||
import passwords
|
||||
import sessions
|
||||
from errors import ApiError
|
||||
|
||||
APP_HOST = os.environ.get("APP_HOST", "0.0.0.0")
|
||||
APP_PORT = int(os.environ.get("APP_PORT", "8080"))
|
||||
APP_ENV = os.environ.get("APP_ENV", "lab")
|
||||
INSTANCE_ID = os.environ.get("INSTANCE_ID", "").strip() or socket.gethostname()
|
||||
|
||||
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}\Z")
|
||||
UUID_RE = re.compile(
|
||||
r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
|
||||
r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\Z")
|
||||
TIMESTAMP_RE = re.compile(
|
||||
r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?Z\Z")
|
||||
IDEMPOTENCY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}\Z")
|
||||
MAX_BODY = 16 * 1024 * 1024
|
||||
|
||||
_draining = threading.Event()
|
||||
_inflight = 0
|
||||
_inflight_lock = threading.Lock()
|
||||
|
||||
|
||||
def drain_seconds() -> float:
|
||||
raw = os.environ.get("DRAIN_SECONDS", "3")
|
||||
try:
|
||||
value = float(raw)
|
||||
except ValueError:
|
||||
return 3.0
|
||||
if value < 0:
|
||||
return 0.0
|
||||
if value > 6:
|
||||
return 6.0
|
||||
return value
|
||||
|
||||
|
||||
def now_utc() -> datetime:
|
||||
current = datetime.now(timezone.utc)
|
||||
return current.replace(microsecond=(current.microsecond // 1000) * 1000)
|
||||
|
||||
|
||||
def is_blank(value: str) -> bool:
|
||||
return value.strip() == ""
|
||||
|
||||
|
||||
def require_object(body):
|
||||
if not isinstance(body, dict):
|
||||
raise ApiError(400, "invalid_request", "Тело должно быть JSON-объектом")
|
||||
|
||||
|
||||
def reject_extra(body: dict, allowed: set):
|
||||
extra = set(body) - allowed
|
||||
if extra:
|
||||
raise ApiError(400, "invalid_request",
|
||||
"Лишние поля: " + ", ".join(sorted(extra)))
|
||||
|
||||
|
||||
def parse_uuid(value, field: str) -> str:
|
||||
if not isinstance(value, str) or not UUID_RE.match(value):
|
||||
raise ApiError(400, "invalid_request", f"Некорректный UUID: {field}")
|
||||
return value.lower()
|
||||
|
||||
|
||||
def parse_display_name(value) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise ApiError(400, "invalid_request", "display_name должен быть строкой")
|
||||
if not (1 <= len(value) <= 100):
|
||||
raise ApiError(400, "invalid_request", "display_name: 1..100 code points")
|
||||
if is_blank(value):
|
||||
raise ApiError(400, "invalid_request", "display_name не может быть пустым")
|
||||
return value
|
||||
|
||||
|
||||
def parse_username(value) -> str:
|
||||
if not isinstance(value, str) or not USERNAME_RE.match(value):
|
||||
raise ApiError(400, "invalid_request", "username: ^[a-z0-9_]{3,32}$")
|
||||
return value
|
||||
|
||||
|
||||
def parse_password(value) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise ApiError(400, "invalid_request", "password должен быть строкой")
|
||||
if not (12 <= len(value) <= 128):
|
||||
raise ApiError(400, "invalid_request", "password: 12..128 code points")
|
||||
if is_blank(value):
|
||||
raise ApiError(400, "invalid_request", "password не может быть пустым")
|
||||
return value
|
||||
|
||||
|
||||
def parse_title(value) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise ApiError(400, "invalid_request", "title должен быть строкой")
|
||||
if not (1 <= len(value) <= 100):
|
||||
raise ApiError(400, "invalid_request", "title: 1..100 code points")
|
||||
if is_blank(value):
|
||||
raise ApiError(400, "invalid_request", "title не может быть пустым")
|
||||
return value
|
||||
|
||||
|
||||
def parse_text(value) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise ApiError(400, "invalid_request", "text должен быть строкой")
|
||||
if not (1 <= len(value) <= 4000):
|
||||
raise ApiError(400, "invalid_request", "text: 1..4000 code points")
|
||||
if is_blank(value):
|
||||
raise ApiError(400, "invalid_request", "text не может быть пустым")
|
||||
return value
|
||||
|
||||
|
||||
def parse_member_ids(value) -> list:
|
||||
if not isinstance(value, list):
|
||||
raise ApiError(400, "invalid_request", "member_ids должен быть массивом")
|
||||
if not (1 <= len(value) <= 100):
|
||||
raise ApiError(400, "invalid_request", "member_ids: 1..100")
|
||||
seen = set()
|
||||
result = []
|
||||
for item in value:
|
||||
uid = parse_uuid(item, "member_ids[]")
|
||||
if uid in seen:
|
||||
raise ApiError(400, "invalid_request", "member_ids содержит дубликаты")
|
||||
seen.add(uid)
|
||||
result.append(uid)
|
||||
return result
|
||||
|
||||
|
||||
def parse_limit(raw, default=50) -> int:
|
||||
if raw is None:
|
||||
return default
|
||||
if isinstance(raw, str) and raw.strip() == "":
|
||||
raise ApiError(400, "invalid_request", "limit должен быть целым")
|
||||
try:
|
||||
value = int(raw)
|
||||
except (TypeError, ValueError):
|
||||
raise ApiError(400, "invalid_request", "limit должен быть целым")
|
||||
if not (1 <= value <= 100):
|
||||
raise ApiError(400, "invalid_request", "limit: 1..100")
|
||||
return value
|
||||
|
||||
|
||||
def parse_optional_cursor(raw):
|
||||
if raw is None:
|
||||
return None
|
||||
if not isinstance(raw, str) or raw.strip() == "":
|
||||
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
||||
return raw
|
||||
|
||||
|
||||
def parse_cursor_timestamp(value: str) -> datetime:
|
||||
if not isinstance(value, str) or not TIMESTAMP_RE.match(value):
|
||||
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
||||
try:
|
||||
parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
|
||||
except ValueError as exc:
|
||||
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
|
||||
return parsed
|
||||
|
||||
|
||||
def parse_idempotency_key(headers) -> str:
|
||||
raw = headers.get("Idempotency-Key")
|
||||
if not isinstance(raw, str) or not IDEMPOTENCY_RE.match(raw):
|
||||
raise ApiError(400, "invalid_request", "Некорректный Idempotency-Key")
|
||||
return raw
|
||||
|
||||
|
||||
def canonical_hash(text: str) -> str:
|
||||
# Порядок ключей не важен. Отсутствующий attachment_ids равен [].
|
||||
# В lab3 схема ещё не принимает attachment_ids: лишнее поле — 400 до хеша.
|
||||
payload = {"attachment_ids": [], "text": text}
|
||||
raw = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
||||
return hashlib.sha256(raw.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def challenge_for(path: str) -> str:
|
||||
if path == "/api/v1/auth/sessions":
|
||||
return 'Basic realm="messenger", charset="UTF-8"'
|
||||
return 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
def bearer_token(headers) -> str:
|
||||
auth = headers.get("Authorization") or ""
|
||||
parts = auth.split(None, 1)
|
||||
if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1].strip():
|
||||
raise ApiError(401, "unauthorized", "Требуется Bearer")
|
||||
return parts[1].strip()
|
||||
|
||||
|
||||
def current_user(headers) -> dict:
|
||||
token = bearer_token(headers)
|
||||
user = db.get_user(sessions.user_id(token))
|
||||
if user is None:
|
||||
raise ApiError(401, "unauthorized", "Сессия недействительна")
|
||||
return user
|
||||
|
||||
|
||||
def basic_credentials(headers) -> tuple[str, str]:
|
||||
auth = headers.get("Authorization") or ""
|
||||
parts = auth.split(None, 1)
|
||||
if len(parts) != 2 or parts[0].lower() != "basic" or not parts[1].strip():
|
||||
raise ApiError(401, "unauthorized", "Требуется Basic")
|
||||
try:
|
||||
decoded = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8")
|
||||
except (ValueError, UnicodeDecodeError) as exc:
|
||||
raise ApiError(401, "unauthorized", "Неверные учётные данные") from exc
|
||||
if ":" not in decoded:
|
||||
raise ApiError(401, "unauthorized", "Неверные учётные данные")
|
||||
username, password = decoded.split(":", 1)
|
||||
return username, password
|
||||
|
||||
|
||||
def encode_cursor(chat_id: str, created_at: str, msg_id: str) -> str:
|
||||
raw = f"{chat_id}|{created_at}|{msg_id}".encode("utf-8")
|
||||
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def decode_cursor(cursor: str, chat_id: str):
|
||||
pad = "=" * (-len(cursor) % 4)
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(cursor + pad).decode("utf-8")
|
||||
except Exception as exc:
|
||||
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
|
||||
parts = raw.split("|")
|
||||
if len(parts) != 3:
|
||||
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
||||
c_chat, c_created, c_id = parts
|
||||
if not UUID_RE.match(c_chat):
|
||||
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
||||
if c_chat.lower() != chat_id:
|
||||
raise ApiError(400, "invalid_request", "cursor от другого чата")
|
||||
return parse_cursor_timestamp(c_created), parse_uuid(c_id, "cursor")
|
||||
|
||||
|
||||
def encode_chat_cursor(created_at: str, chat_id: str) -> str:
|
||||
raw = f"chat|{created_at}|{chat_id}".encode("utf-8")
|
||||
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def decode_chat_cursor(cursor: str):
|
||||
pad = "=" * (-len(cursor) % 4)
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(cursor + pad).decode("utf-8")
|
||||
except Exception as exc:
|
||||
raise ApiError(400, "invalid_request", "Некорректный cursor") from exc
|
||||
parts = raw.split("|")
|
||||
if len(parts) != 3 or parts[0] != "chat":
|
||||
raise ApiError(400, "invalid_request", "Некорректный cursor")
|
||||
return parse_cursor_timestamp(parts[1]), parse_uuid(parts[2], "cursor")
|
||||
|
||||
|
||||
def create_user(body) -> dict:
|
||||
require_object(body)
|
||||
reject_extra(body, {"username", "display_name", "password"})
|
||||
username = parse_username(body.get("username"))
|
||||
display_name = parse_display_name(body.get("display_name"))
|
||||
password = parse_password(body.get("password"))
|
||||
return db.create_user(username, display_name, passwords.hash_password(password), now_utc())
|
||||
|
||||
|
||||
def create_session(headers) -> dict:
|
||||
username, password = basic_credentials(headers)
|
||||
row = None
|
||||
try:
|
||||
row = db.user_for_login(username)
|
||||
except ApiError:
|
||||
raise
|
||||
stored = row[3] if row is not None else passwords.DUMMY_HASH
|
||||
password_ok = passwords.verify_password(password, stored)
|
||||
if row is None or not password_ok:
|
||||
raise ApiError(401, "unauthorized", "Неверные учётные данные")
|
||||
token = secrets.token_urlsafe(32)
|
||||
ttl = sessions.session_ttl()
|
||||
expires = now_utc() + timedelta(seconds=ttl)
|
||||
sessions.create(token, str(row[0]), ttl)
|
||||
return {
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": db.format_ts(expires),
|
||||
"user": db.user_json((row[0], row[1], row[2], row[4])),
|
||||
}
|
||||
|
||||
|
||||
def logout(headers) -> None:
|
||||
token = bearer_token(headers)
|
||||
sessions.user_id(token)
|
||||
sessions.revoke(token)
|
||||
|
||||
|
||||
def create_chat(body, actor: dict) -> dict:
|
||||
require_object(body)
|
||||
reject_extra(body, {"title", "member_ids"})
|
||||
title = parse_title(body.get("title"))
|
||||
member_ids = parse_member_ids(body.get("member_ids"))
|
||||
if actor["id"] not in member_ids:
|
||||
raise ApiError(400, "invalid_request", "вызывающий должен быть в member_ids")
|
||||
return db.create_chat(title, member_ids, now_utc())
|
||||
|
||||
|
||||
def list_chats(actor: dict, limit: int, cursor) -> dict:
|
||||
decoded = decode_chat_cursor(cursor) if cursor else None
|
||||
page = db.list_chats(actor["id"], limit, decoded)
|
||||
next_cursor = None
|
||||
if page["next_cursor_parts"] is not None:
|
||||
created, chat_id = page["next_cursor_parts"]
|
||||
next_cursor = encode_chat_cursor(db.format_ts(created), chat_id)
|
||||
return {"items": page["items"], "next_cursor": next_cursor}
|
||||
|
||||
|
||||
def create_message(chat_id: str, body, actor: dict, idem_key: str) -> dict:
|
||||
cid = parse_uuid(chat_id, "chat_id")
|
||||
require_object(body)
|
||||
reject_extra(body, {"text"})
|
||||
text = parse_text(body.get("text"))
|
||||
path = "/api/v1/chats/%s/messages" % cid
|
||||
return db.create_message_idempotent(
|
||||
cid, actor["id"], text, now_utc(), "POST", path, idem_key, canonical_hash(text),
|
||||
)
|
||||
|
||||
|
||||
def list_messages(chat_id: str, actor: dict, limit: int, cursor) -> dict:
|
||||
cid = parse_uuid(chat_id, "chat_id")
|
||||
decoded = decode_cursor(cursor, cid) if cursor else None
|
||||
page = db.list_messages(cid, actor["id"], limit, decoded)
|
||||
next_cursor = None
|
||||
if page["next_cursor_parts"] is not None:
|
||||
created, message_id = page["next_cursor_parts"]
|
||||
next_cursor = encode_cursor(cid, db.format_ts(created), message_id)
|
||||
return {"items": page["items"], "next_cursor": next_cursor}
|
||||
|
||||
|
||||
class FastThreadingHTTPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
|
||||
daemon_threads = True
|
||||
block_on_close = False
|
||||
allow_reuse_address = True
|
||||
request_queue_size = 256
|
||||
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
server_version = "mtusi-messenger/3.0"
|
||||
protocol_version = "HTTP/1.0"
|
||||
|
||||
def log_message(self, fmt, *args):
|
||||
return
|
||||
|
||||
def _request_id(self) -> str:
|
||||
return self.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
|
||||
def _send_json(self, status: int, payload, request_id: str, extra_headers=None):
|
||||
body = b""
|
||||
if status != 204:
|
||||
body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
self.send_response(status)
|
||||
if status != 204:
|
||||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.send_header("X-Request-Id", request_id)
|
||||
self.send_header("X-Instance-Id", INSTANCE_ID)
|
||||
self.send_header("Connection", "close")
|
||||
for key, value in (extra_headers or {}).items():
|
||||
self.send_header(key, value)
|
||||
self.end_headers()
|
||||
if body:
|
||||
self.wfile.write(body)
|
||||
|
||||
def _send_error(self, status: int, code: str, message: str, request_id: str, extra_headers=None):
|
||||
self._send_json(
|
||||
status,
|
||||
{"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
request_id,
|
||||
extra_headers,
|
||||
)
|
||||
|
||||
def _read_body(self):
|
||||
length = self.headers.get("Content-Length")
|
||||
if not length:
|
||||
return None
|
||||
try:
|
||||
size = int(length)
|
||||
except ValueError as exc:
|
||||
raise ApiError(400, "invalid_request", "Некорректный Content-Length") from exc
|
||||
if size > MAX_BODY:
|
||||
raise ApiError(413, "payload_too_large", "Тело слишком большое")
|
||||
raw = self.rfile.read(size)
|
||||
ctype = (self.headers.get("Content-Type") or "").split(";")[0].strip()
|
||||
if ctype and ctype != "application/json":
|
||||
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
|
||||
if not raw:
|
||||
raise ApiError(400, "invalid_request", "Пустое тело")
|
||||
try:
|
||||
return json.loads(raw.decode("utf-8"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError) as exc:
|
||||
raise ApiError(400, "invalid_request", "Malformed JSON") from exc
|
||||
|
||||
def do_GET(self):
|
||||
self._dispatch("GET")
|
||||
|
||||
def do_POST(self):
|
||||
self._dispatch("POST")
|
||||
|
||||
def do_DELETE(self):
|
||||
self._dispatch("DELETE")
|
||||
|
||||
def _dispatch(self, method: str):
|
||||
global _inflight
|
||||
with _inflight_lock:
|
||||
_inflight += 1
|
||||
rid = self._request_id()
|
||||
parsed = urlparse(self.path)
|
||||
path = parsed.path.rstrip("/") or "/"
|
||||
query = parse_qs(parsed.query, keep_blank_values=True)
|
||||
try:
|
||||
self._route(method, path, query, rid)
|
||||
except ApiError as exc:
|
||||
headers = {}
|
||||
if exc.status == 401:
|
||||
headers["WWW-Authenticate"] = challenge_for(path)
|
||||
self._send_error(exc.status, exc.code, exc.message, rid, headers)
|
||||
except BrokenPipeError:
|
||||
pass
|
||||
except Exception:
|
||||
sys.stderr.write("internal error on %s %s\n" % (method, path))
|
||||
self._send_error(500, "internal_error", "Внутренняя ошибка", rid)
|
||||
finally:
|
||||
with _inflight_lock:
|
||||
_inflight -= 1
|
||||
|
||||
def _route(self, method: str, path: str, query: dict, rid: str):
|
||||
if method == "GET" and path == "/health/live":
|
||||
return self._send_json(200, {"status": "ok"}, rid)
|
||||
if method == "GET" and path == "/health/ready":
|
||||
if _draining.is_set():
|
||||
raise ApiError(503, "unavailable", "Реплика останавливается")
|
||||
if db.ping() and sessions.ping():
|
||||
return self._send_json(200, {"status": "ok"}, rid)
|
||||
raise ApiError(503, "unavailable", "Зависимость недоступна")
|
||||
if _draining.is_set():
|
||||
raise ApiError(503, "unavailable", "Реплика останавливается")
|
||||
|
||||
if method == "POST" and path == "/api/v1/users":
|
||||
return self._send_json(201, create_user(self._read_body()), rid)
|
||||
if method == "POST" and path == "/api/v1/auth/sessions":
|
||||
return self._send_json(201, create_session(self.headers), rid)
|
||||
if method == "DELETE" and path == "/api/v1/auth/sessions/current":
|
||||
logout(self.headers)
|
||||
return self._send_json(204, None, rid)
|
||||
if method == "GET" and path == "/api/v1/users/me":
|
||||
return self._send_json(200, current_user(self.headers), rid)
|
||||
|
||||
if method == "POST" and path == "/api/v1/chats":
|
||||
actor = current_user(self.headers)
|
||||
return self._send_json(201, create_chat(self._read_body(), actor), rid)
|
||||
if method == "GET" and path == "/api/v1/chats":
|
||||
actor = current_user(self.headers)
|
||||
limit = parse_limit(query.get("limit", [None])[0])
|
||||
cursor = parse_optional_cursor(query.get("cursor", [None])[0])
|
||||
return self._send_json(200, list_chats(actor, limit, cursor), rid)
|
||||
|
||||
match = re.fullmatch(r"/api/v1/chats/([^/]+)", path)
|
||||
if match and method == "GET":
|
||||
actor = current_user(self.headers)
|
||||
return self._send_json(200, db.get_chat(parse_uuid(match.group(1), "chat_id"), actor["id"]), rid)
|
||||
|
||||
match = re.fullmatch(r"/api/v1/chats/([^/]+)/messages", path)
|
||||
if match and method == "POST":
|
||||
actor = current_user(self.headers)
|
||||
idem_key = parse_idempotency_key(self.headers)
|
||||
body = create_message(match.group(1), self._read_body(), actor, idem_key)
|
||||
return self._send_json(201, body, rid)
|
||||
if match and method == "GET":
|
||||
actor = current_user(self.headers)
|
||||
limit = parse_limit(query.get("limit", [None])[0])
|
||||
cursor = parse_optional_cursor(query.get("cursor", [None])[0])
|
||||
return self._send_json(200, list_messages(match.group(1), actor, limit, cursor), rid)
|
||||
|
||||
raise ApiError(404, "not_found", "Маршрут не найден")
|
||||
|
||||
|
||||
def _inflight_now() -> int:
|
||||
with _inflight_lock:
|
||||
return _inflight
|
||||
|
||||
|
||||
def main():
|
||||
try:
|
||||
db.init()
|
||||
except Exception:
|
||||
sys.stderr.write("database is not configured\n")
|
||||
try:
|
||||
sessions.init()
|
||||
except Exception:
|
||||
sys.stderr.write("session store is not configured\n")
|
||||
|
||||
server = FastThreadingHTTPServer((APP_HOST, APP_PORT), Handler)
|
||||
|
||||
def drain_and_stop():
|
||||
time.sleep(drain_seconds())
|
||||
deadline = time.monotonic() + 2
|
||||
while time.monotonic() < deadline and _inflight_now() > 0:
|
||||
time.sleep(0.05)
|
||||
server.shutdown()
|
||||
|
||||
def shutdown(signum, frame):
|
||||
if _draining.is_set():
|
||||
return
|
||||
_draining.set()
|
||||
sys.stderr.write("SIGTERM instance=%s stop accepting\n" % INSTANCE_ID)
|
||||
threading.Thread(target=drain_and_stop, daemon=True).start()
|
||||
|
||||
signal.signal(signal.SIGTERM, shutdown)
|
||||
signal.signal(signal.SIGINT, shutdown)
|
||||
sys.stderr.write(
|
||||
"listening on %s:%s env=%s instance=%s\n" % (APP_HOST, APP_PORT, APP_ENV, INSTANCE_ID)
|
||||
)
|
||||
try:
|
||||
server.serve_forever(poll_interval=0.1)
|
||||
finally:
|
||||
server.server_close()
|
||||
db.close()
|
||||
sys.stderr.write("stopped instance=%s\n" % INSTANCE_ID)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,85 @@
|
||||
"""Сессии в Valkey. Ключ — SHA-256 токена, TTL равен остатку жизни сессии.
|
||||
|
||||
Источник истины сессий — общий Valkey, не память процесса API.
|
||||
AOF и volume сохраняют ключ при перезапуске хранилища.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
import redis
|
||||
|
||||
from errors import ApiError
|
||||
|
||||
_client: redis.Redis | None = None
|
||||
|
||||
|
||||
def session_ttl() -> int:
|
||||
raw = os.environ.get("SESSION_TTL_SECONDS", "3600")
|
||||
try:
|
||||
value = int(raw)
|
||||
except ValueError:
|
||||
return 3600
|
||||
return value if value >= 1 else 1
|
||||
|
||||
|
||||
def redis_url() -> str:
|
||||
path = os.environ.get("CACHE_URL_FILE", "").strip()
|
||||
if path and Path(path).is_file():
|
||||
return Path(path).read_text(encoding="utf-8").strip()
|
||||
return os.environ.get("REDIS_URL", "").strip()
|
||||
|
||||
|
||||
def init() -> None:
|
||||
global _client
|
||||
url = redis_url()
|
||||
if not url:
|
||||
_client = None
|
||||
return
|
||||
_client = redis.Redis.from_url(
|
||||
url, socket_connect_timeout=0.5, socket_timeout=0.5,
|
||||
decode_responses=True)
|
||||
|
||||
|
||||
def _key(token: str) -> str:
|
||||
digest = hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||||
return "session:" + digest
|
||||
|
||||
|
||||
def _require() -> redis.Redis:
|
||||
if _client is None:
|
||||
raise ApiError(503, "unavailable", "Хранилище сессий недоступно")
|
||||
return _client
|
||||
|
||||
|
||||
def ping() -> bool:
|
||||
try:
|
||||
return bool(_require().ping())
|
||||
except (ApiError, redis.RedisError):
|
||||
return False
|
||||
|
||||
|
||||
def create(token: str, user_id: str, ttl: int) -> None:
|
||||
try:
|
||||
_require().set(_key(token), user_id, ex=ttl)
|
||||
except (ApiError, redis.RedisError) as exc:
|
||||
raise ApiError(503, "unavailable", "Хранилище сессий недоступно") from exc
|
||||
|
||||
|
||||
def user_id(token: str) -> str:
|
||||
try:
|
||||
value = _require().get(_key(token))
|
||||
except (ApiError, redis.RedisError) as exc:
|
||||
raise ApiError(503, "unavailable", "Хранилище сессий недоступно") from exc
|
||||
if not value:
|
||||
raise ApiError(401, "unauthorized", "Сессия недействительна")
|
||||
return value
|
||||
|
||||
|
||||
def revoke(token: str) -> None:
|
||||
try:
|
||||
_require().delete(_key(token))
|
||||
except (ApiError, redis.RedisError) as exc:
|
||||
raise ApiError(503, "unavailable", "Хранилище сессий недоступно") from exc
|
||||
@@ -0,0 +1,64 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Проверки уровня 4, которые не входят в публичный smoke: разнос реплик и гонка ключа."""
|
||||
import threading
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
|
||||
def instances_of(c, actor, n=24):
|
||||
seen = []
|
||||
for _ in range(n):
|
||||
seen.append(c.call("GET", "/api/v1/users/me", actor=actor, schema="User")["headers"]["X-Instance-Id"])
|
||||
return seen
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Lab3 level-4: two instances and concurrent idempotency")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
seen = instances_of(c, alice)
|
||||
uniq = sorted(set(seen))
|
||||
check(len(uniq) >= 2, "LB did not spread one session across two API replicas: %s" % uniq)
|
||||
|
||||
key = "same-" + uuid.uuid4().hex
|
||||
text = "общий ключ " + key
|
||||
workers = 8
|
||||
barrier = threading.Barrier(workers)
|
||||
|
||||
def once(_n):
|
||||
local = Client(args.base_url, args.ca_file, timeout=10)
|
||||
barrier.wait()
|
||||
return local.message(alice, chat, text, key=key)
|
||||
|
||||
with ThreadPoolExecutor(max_workers=workers) as pool:
|
||||
results = list(pool.map(once, range(workers)))
|
||||
ids = {item["json"]["id"] for item in results}
|
||||
bodies = {item["json"]["text"] for item in results}
|
||||
served = sorted({item["headers"]["X-Instance-Id"] for item in results})
|
||||
check(len(ids) == 1, "concurrent idempotency created more than one message")
|
||||
check(bodies == {text}, "concurrent replay changed text")
|
||||
check(len(served) >= 2, "concurrent posts did not hit two replicas: %s" % served)
|
||||
replay = c.message(alice, chat, text, key=key)["json"]
|
||||
check(replay == results[0]["json"], "sequential replay differs")
|
||||
c.call(
|
||||
"POST",
|
||||
"/api/v1/chats/" + chat["id"] + "/messages",
|
||||
409,
|
||||
actor=alice,
|
||||
body={"text": "другой текст " + key},
|
||||
headers={"Idempotency-Key": key},
|
||||
)
|
||||
shared = "shared-" + uuid.uuid4().hex
|
||||
left = c.message(alice, chat, "алиса " + shared, key=shared)["json"]
|
||||
right = c.message(bob, chat, "боб " + shared, key=shared)["json"]
|
||||
check(left["id"] != right["id"], "same key must be independent per user")
|
||||
page = c.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", actor=bob, schema="MessagePage")["json"]
|
||||
copies = [item for item in page["items"] if item["text"] == text]
|
||||
check(len(copies) == 1, "history contains duplicate of the idempotent message")
|
||||
print("PASS: level4 spread=%s parallel_instances=%s" % (",".join(uniq), ",".join(served)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
Reference in New Issue
Block a user