forked from mtusi2026/mtusi2026lab2
ЛР 2: PostgreSQL, сессии в Valkey, трек 2
This commit is contained in:
@@ -9,3 +9,21 @@ 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
|
||||
# --- Реализация lab2: сервер и деградация (перенесено из lab1) ---
|
||||
GRACEFUL_TIMEOUT=8
|
||||
MAX_INFLIGHT_REQUESTS=64
|
||||
MAX_BODY_BYTES=65536
|
||||
MAX_RSS_MB=0
|
||||
# --- Реализация lab2: PostgreSQL ---
|
||||
DB_POOL_MIN=1
|
||||
DB_POOL_MAX=10
|
||||
DB_POOL_TIMEOUT=3
|
||||
DB_CONNECT_TIMEOUT=3
|
||||
DB_STATEMENT_TIMEOUT_MS=5000
|
||||
DB_OP_TIMEOUT=6
|
||||
REQUEST_TIMEOUT=8
|
||||
DB_READY_TIMEOUT=1.5
|
||||
# --- Реализация lab2: кэш сессий в Valkey ---
|
||||
SESSION_CACHE_TTL_SECONDS=30
|
||||
SESSION_SWEEP_SECONDS=60
|
||||
CACHE_TIMEOUT=0.2
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
name: Application
|
||||
on: [push, pull_request]
|
||||
permissions:
|
||||
contents: read
|
||||
jobs:
|
||||
app:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.12'
|
||||
- name: Bootstrap local env and secrets
|
||||
run: make bootstrap
|
||||
- name: Start stack
|
||||
run: docker compose --env-file .env up -d --build
|
||||
- name: Wait for readiness
|
||||
run: |
|
||||
for i in $(seq 1 60); do
|
||||
if curl -fsS http://localhost:8080/health/ready; then exit 0; fi
|
||||
sleep 2
|
||||
done
|
||||
docker compose --env-file .env ps
|
||||
docker compose --env-file .env logs --tail=200
|
||||
exit 1
|
||||
- name: Migrations are idempotent
|
||||
run: docker compose --env-file .env run --rm migrate
|
||||
- name: Public smoke
|
||||
run: make test PYTHON=python
|
||||
- name: Own checks
|
||||
run: make test-custom PYTHON=python
|
||||
- name: Persistence with restart hook
|
||||
run: make test-persistence ACTION_SCRIPT=scripts/restart.sh PYTHON=python
|
||||
- name: Logs on failure
|
||||
if: failure()
|
||||
run: docker compose --env-file .env logs --tail=200
|
||||
- name: Tear down
|
||||
if: always()
|
||||
run: docker compose --env-file .env down -v
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
FROM python:3.12.8-slim-bookworm@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_DISABLE_PIP_VERSION_CHECK=1 \
|
||||
PIP_DEFAULT_TIMEOUT=120 \
|
||||
PIP_RETRIES=10
|
||||
|
||||
RUN groupadd --system --gid 10001 app \
|
||||
&& useradd --system --uid 10001 --gid app --home-dir /app --shell /usr/sbin/nologin app
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-deps -r requirements.txt
|
||||
|
||||
COPY app/ app/
|
||||
COPY migrations/ migrations/
|
||||
COPY scripts/migrate.py scripts/migrate.py
|
||||
|
||||
USER 10001:10001
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
|
||||
CMD ["python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status == 200 else 1)"]
|
||||
|
||||
STOPSIGNAL SIGTERM
|
||||
|
||||
CMD ["sh", "-c", "exec uvicorn app.main:app --host \"${APP_HOST:-0.0.0.0}\" --port \"${APP_PORT:-8080}\" --timeout-graceful-shutdown \"${GRACEFUL_TIMEOUT:-8}\""]
|
||||
@@ -4,10 +4,16 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
COMPOSE ?= docker compose --env-file .env
|
||||
|
||||
.PHONY: help check validate test load test-persistence bootstrap build up down logs ps migrate psql test-custom expiry dependency outages explain track2 evidence
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "bootstrap: local .env and secrets; build/up/down: compose stack; migrate: apply SQL migrations"
|
||||
@echo "test-custom: own level-4 checks; expiry: short-TTL instance; dependency: cache and database outages"
|
||||
@echo "outages: revocation vs cache restart, hung database; evidence: full run into evidence/"
|
||||
@echo "explain: history query plan on 10k rows; track2: grade-5 experiment; test-persistence: restart hook"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -24,3 +30,49 @@ load:
|
||||
test-persistence:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
bootstrap:
|
||||
sh scripts/bootstrap.sh
|
||||
|
||||
build:
|
||||
$(COMPOSE) build
|
||||
|
||||
up:
|
||||
$(COMPOSE) up -d --build
|
||||
|
||||
down:
|
||||
$(COMPOSE) down
|
||||
|
||||
logs:
|
||||
$(COMPOSE) logs --tail=100 api
|
||||
|
||||
ps:
|
||||
$(COMPOSE) ps
|
||||
|
||||
migrate:
|
||||
$(COMPOSE) run --rm migrate
|
||||
|
||||
psql:
|
||||
$(COMPOSE) exec postgres psql -U messenger -d messenger
|
||||
|
||||
test-custom:
|
||||
$(PYTHON) student-tests/test_auth_sessions.py --base-url "$(BASE_URL)"
|
||||
$(PYTHON) student-tests/test_storage_rules.py --base-url "$(BASE_URL)"
|
||||
|
||||
expiry:
|
||||
sh student-tests/expiry.sh
|
||||
|
||||
dependency:
|
||||
sh student-tests/dependency.sh
|
||||
|
||||
outages:
|
||||
$(PYTHON) student-tests/test_outages.py --base-url "$(BASE_URL)"
|
||||
|
||||
explain:
|
||||
sh student-tests/explain.sh
|
||||
|
||||
track2:
|
||||
TOTAL=$(or $(TOTAL),120000) sh student-tests/track2.sh
|
||||
|
||||
evidence:
|
||||
sh student-tests/evidence.sh
|
||||
|
||||
@@ -1,37 +1,189 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Автор, группа: Курлова Алёна Алексеевна, БВТ2301
|
||||
- Целевая оценка; выбранный трек 5: 5, трек 2 «План запроса и восстановление»
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.6, Uvicorn 0.34.0, psycopg 3.3.6 (+psycopg-pool), valkey-py 6.2.0, argon2-cffi 25.1.0 — документация перечисленных библиотек; документация PostgreSQL 17 (transactions, EXPLAIN, pg_dump/pg_restore, типы данных), Valkey persistence, RFC 7617, RFC 9106. Реализация, свои тесты и стенд эксперимента написаны с помощью ИИ-ассистента (Claude Code); все прогоны и доказательства выполнены автором. Отдельно просмотрены публичные ревью преподавателя к PR других студентов этой же лабораторной и проверено, закрыты ли названные там случаи в этой работе: сохранение NUL в тексте, отзыв сессии против возврата кэша, зависшая БД, тело запроса на входе, Unicode-пробелы. Четыре из них требовали правок, остальные уже работали; на каждый добавлен свой тест.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Docker (проверено 29.7.2) с плагином Compose (v5.5.1), `make`, Python 3.9+ на хосте (только для публичных и своих тестов) и свободный порт 8080. Образы закреплены по digest, Python-зависимости — по версиям в `requirements.txt`.
|
||||
|
||||
```sh
|
||||
make bootstrap # создаёт локальный .env и secrets/ (пароль генерируется на месте)
|
||||
make up # build + postgres + valkey + миграции + api
|
||||
curl -i http://localhost:8080/health/ready
|
||||
make test # публичный smoke
|
||||
make test-custom # свои проверки уровня 4
|
||||
```
|
||||
|
||||
`make bootstrap` создаёт `.env` из `.env.example` и три файла в `secrets/`: `postgres_password` (случайный), `database_url`, `cache_url`. Каталоги `secrets/`, `backups/` и `.env` закрыты `.gitignore`; в репозиторий попадают только пути к секретам, не значения.
|
||||
|
||||
Миграции применяет отдельный одноразовый сервис `migrate` (`python scripts/migrate.py`), от которого `api` зависит через `service_completed_successfully`. Повторный запуск (`make migrate`) печатает `skip 0001_init` и ничего не меняет: применённые версии и их sha256 лежат в таблице `schema_migrations`, при изменении уже применённого файла запуск падает с ошибкой. Выполняется под advisory lock, поэтому одновременный запуск двух runner-ов безопасен.
|
||||
|
||||
Все проверки и эксперименты одной командой — она пересоздаёт стенд с нуля и складывает вывод каждого шага в `evidence/`:
|
||||
|
||||
```sh
|
||||
make evidence
|
||||
```
|
||||
|
||||
Те же сценарии по отдельности:
|
||||
|
||||
```sh
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh # рестарт API и всех хранилищ
|
||||
make expiry # истечение сессии при TTL=2 с
|
||||
make outages # отзыв сессии против рестарта кэша, зависшая БД
|
||||
make dependency # отказ Valkey, затем отказ PostgreSQL
|
||||
make explain # план истории на таблице не меньше 10 000 сообщений
|
||||
TOTAL=120000 make track2 # трек 5: индексы + backup/restore
|
||||
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load-cache.json
|
||||
# тот же прогон при остановленном Valkey даёт вторую точку сравнения:
|
||||
docker compose --env-file .env stop valkey
|
||||
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load-nocache.json
|
||||
docker compose --env-file .env start valkey
|
||||
```
|
||||
|
||||
Безопасная остановка: `make down` (том `pgdata` сохраняется, данные остаются). Намеренное удаление учебных данных: `docker compose --env-file .env down -v` — удаляет том базы вместе со всеми данными; дополнительно `rm -rf backups/` удаляет локальные дампы. `student-tests/track2.sh` сам удаляет свой временный контейнер и том восстановления (`KEEP=1` оставляет их для осмотра). `TOTAL` задаёт целевой размер истории: засев добивает таблицу до этого числа и при повторном запуске не добавляет ничего, поэтому прогоны воспроизводимы.
|
||||
|
||||
Переменные `.env.example` соответствуют реальной конфигурации: `APP_HOST/APP_PORT/GRACEFUL_TIMEOUT` читает команда uvicorn в `Dockerfile`, остальные — `app/config.py`. `DATABASE_URL_FILE` и `CACHE_URL_FILE` в контейнере указывают на docker secrets (`/run/secrets/...`), которые compose монтирует из `secrets/`.
|
||||
|
||||
| Переменная | Что задаёт | Значение по умолчанию |
|
||||
| --- | --- | --- |
|
||||
| `SESSION_TTL_SECONDS` | срок жизни сессии | 3600 |
|
||||
| `SESSION_CACHE_TTL_SECONDS` | срок жизни записи в кэше сессий | 30 |
|
||||
| `SESSION_SWEEP_SECONDS` | период удаления истёкших сессий из БД | 60 |
|
||||
| `SESSION_STORE` | источник истины для сессий | postgres |
|
||||
| `DB_POOL_MIN`, `DB_POOL_MAX` | границы пула соединений | 1, 10 |
|
||||
| `DB_POOL_TIMEOUT`, `DB_CONNECT_TIMEOUT` | ожидание свободного соединения и подключения, с | 3, 3 |
|
||||
| `DB_STATEMENT_TIMEOUT_MS` | `statement_timeout` и `lock_timeout` на сервере | 5000 |
|
||||
| `DB_OP_TIMEOUT` | клиентский лимит на один SQL-запрос, с | 6 |
|
||||
| `DB_READY_TIMEOUT` | лимит проверки готовности БД, с | 1.5 |
|
||||
| `REQUEST_TIMEOUT` | потолок на обработку всего HTTP-запроса, с | 8 |
|
||||
| `CACHE_TIMEOUT` | таймаут на операцию с Valkey, с | 0.2 |
|
||||
| `MAX_INFLIGHT_REQUESTS` | одновременных запросов, сверх — 429 | 64 |
|
||||
| `MAX_BODY_BYTES` | размер тела, сверх — 413 | 65536 |
|
||||
| `MAX_RSS_MB` | лимит памяти процесса, сверх — 503 на запись (0 — выключен) | 0 |
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
клиент → uvicorn/FastAPI (app/) ──► PostgreSQL 17.7 (источник истины: users, chats, chat_members, messages, sessions)
|
||||
└─► Valkey 8.1 (кэш сессий с TTL, намеренно без persistence)
|
||||
migrate (одноразовый) ──► PostgreSQL (versioned SQL из migrations/)
|
||||
```
|
||||
|
||||
**Источник истины.** Все обязательные данные и сессии лежат в PostgreSQL на томе `pgdata`. Valkey — кэш: он ускоряет проверку токена, но не хранит ничего, чего нет в базе. Поэтому потеря Valkey не теряет данные, а только замедляет работу; `SESSION_STORE=postgres` фиксирует это решение в конфигурации.
|
||||
|
||||
**Кэш сессий намеренно без persistence.** У Valkey выключены и RDB (`--save ""`), и AOF (`--appendonly no`). Это не упущение, а требование безопасности: если кэш переживает рестарт, он может воскресить запись об уже отозванной сессии и вернуть доступ по мёртвому токену. С volatile-кэшом после любого рестарта таблица сессий в PostgreSQL остаётся единственным источником правды, и каждый токен проверяется заново. Persistence кэша обязателен только если он единственное хранилище сессий — у нас это не так.
|
||||
|
||||
**Отзыв сессии устойчив к кэшу.** `DELETE /auth/sessions/current` сначала удаляет ключ из Valkey и только потом строку из PostgreSQL. Поэтому 204 означает, что токен мёртв в обоих местах; обратного порядка (сначала БД, потом кэш) мы избегаем именно потому, что при сбое второго шага кэш продолжал бы отдавать отозванную сессию. Если кэш недоступен, logout возвращает 503 и сессию не удаляет: выход не подтверждается, пока нельзя гарантировать, что кэш больше не отдаст токен. Клиент повторяет запрос; проверено тестом `logout_is_not_confirmed_while_cache_is_down`.
|
||||
|
||||
**Схема и ограничения** (`migrations/0001_init.sql`). `users.username` — `UNIQUE` плюс `CHECK (username ~ '^[a-z0-9_]{3,32}$')`, так что уникальность username гарантирует база, а не только проверка в коде. `chat_members` — таблица связи с `PRIMARY KEY (chat_id, user_id)` и внешними ключами на `chats` и `users`. `messages` ссылается на `chats` и `users`. `sessions` хранит `token_hash bytea PRIMARY KEY`, `user_id`, `created_at`, `expires_at`.
|
||||
|
||||
**Почему текст хранится в `bytea`.** `display_name`, `title` и `messages.text` — `bytea` с UTF-8 байтами, а не `text`. Причина: контракт разрешает в тексте любые Unicode code points, включая U+0000, а тип `text` в PostgreSQL физически не может содержать нулевой байт — попытка записи даёт `invalid byte sequence for encoding "UTF8": 0x00`, то есть 500 на валидном по контракту запросе. Хранение байтами даёт точный round-trip любой строки; длину в code points проверяет приложение (1..100 для имён и заголовков, 1..4000 для текста), а база дополнительно ограничивает `octet_length`. Цена решения — SQL-запросы к этим столбцам нельзя сравнивать как текст: в своих скриптах используются `convert_to`, `position` и `encode`, а не `LIKE` по `convert_from` (последний падает как раз на строках с NUL).
|
||||
|
||||
**Транзакционные границы.** Соединения работают в autocommit, то есть один запрос — одна транзакция. Явная транзакция открывается там, где составная операция должна быть атомарной: создание чата вставляет строку в `chats` и строки в `chat_members` одним `BEGIN ... COMMIT`. Участники добавляются `INSERT ... SELECT u.id FROM users WHERE u.id = ANY(%s)`, и если вставилось меньше строк, чем запрошено, значит кто-то из `member_ids` не существует — поднимается исключение, транзакция откатывается, клиент получает 400, а в базе не остаётся чата без участников. Отправка сообщения — один оператор `INSERT ... SELECT ... WHERE EXISTS (SELECT 1 FROM chat_members ...)`: проверка членства и запись атомарны, отдельного запроса на проверку доступа нет, посторонний получает 404 (0 строк).
|
||||
|
||||
**Индекс истории.** `messages_history_idx (chat_id, created_at, id)` повторяет порядок сортировки контракта, поэтому страница читается диапазонным сканом индекса без сортировки. Keyset-пагинация сравнивает кортеж: `(created_at, id) > (:ts, :id)`. Цена страницы не зависит от её номера — измерения в разделе эксперимента.
|
||||
|
||||
**Пагинация и курсор.** Курсор перенесён из lab1: base64 от `{scope, created_at, id}`, где scope — `messages:<chat_id>` или `chats:<user_id>`. Курсор проверяется строго (формат времени с микросекундами, UUID, совпадение с заново закодированным значением), поэтому изменённый вручную курсор и курсор другого чата дают 400. Пустая строка в `cursor` или `limit` — это именно неверное значение, а не отсутствие параметра: такой запрос получает 400. Повторов и пропусков при обходе неизменной истории нет; snapshot между HTTP-запросами не гарантируется. Время ставит сервер (`clock_timestamp()`, микросекунды), порядок внутри одной микросекунды разводится по `id`.
|
||||
|
||||
**Аутентификация.** `POST /api/v1/users` принимает `password` (12–128 code points) и хеширует его Argon2id (`argon2-cffi`, `time_cost=2, memory_cost=19456 KiB, parallelism=1`). Хеширование и проверка выполняются в threadpool, чтобы KDF не блокировал event loop. `POST /api/v1/auth/sessions` принимает только Basic и не принимает тело: любой непустой body даёт 400. Вход выдаёт opaque-токен `secrets.token_urlsafe(32)` — 256 бит энтропии; в базу пишется только `sha256(token)`, самого токена сервер не хранит. Остальные endpoint принимают только Bearer; Basic на них — 401 с `WWW-Authenticate: Bearer`, `X-User-Id` игнорируется полностью. Неверный пароль и несуществующий пользователь дают один и тот же 401: при отсутствии пользователя проверка выполняется против фиктивного хеша, чтобы ответ не отличался ни телом, ни временем. Повреждённый UTF-8 в теле или в Basic-строке не «исправляется» заменой символов, а отклоняется (400 и 401 соответственно).
|
||||
|
||||
**Валидация входа.** Тело читается потоком с лимитом `MAX_BODY_BYTES` (413), `Content-Type` обязателен (415 на любой другой), лишние и недостающие поля — 400. Некорректный JSON, в том числе битые числа (`1e999`, `NaN`), обрезанное тело и глубокая вложенность, вызывающая `RecursionError`, дают 400, а не 500. Обязательные строки не могут состоять только из пробельных символов, причём к пробельным приравнены и невидимые `U+200B..U+200D`, `U+2060`, `U+FEFF`.
|
||||
|
||||
**Кэш сессий.** Ключ `session:<sha256-hex>` — коллизий между пользователями быть не может, значение — публичные поля владельца токена, TTL = `min(SESSION_CACHE_TTL_SECONDS, остаток до expires_at)`. Промах читает `sessions JOIN users` с условием `expires_at > now()` и снова наполняет кэш. Истёкшие строки убирает фоновая задача раз в `SESSION_SWEEP_SECONDS`; TTL абсолютный, рестарт его не продлевает.
|
||||
|
||||
**Пул и таймауты.** `AsyncConnectionPool` с `min_size=1`, `max_size=10`, ожиданием свободного соединения 3 с, `connect_timeout=3`; на каждом соединении выставлены `statement_timeout=5000`, `lock_timeout=5000`, `idle_in_transaction_session_timeout=10000`. Серверных таймаутов недостаточно: если процесс БД заморожен, он не успеет их применить, поэтому каждый SQL-запрос дополнительно обёрнут клиентским лимитом `DB_OP_TIMEOUT`, а весь HTTP-запрос — потолком `REQUEST_TIMEOUT` в middleware. Соединение, на котором сработал клиентский таймаут, закрывается, чтобы пул заменил его, а не выдал следующему запросу. Все запросы параметризованы psycopg (`%s`), конкатенации пользовательских данных в SQL нет.
|
||||
|
||||
**Деградация.** `OperationalError`, `InterfaceError`, таймаут пула и клиентские таймауты превращаются в 503 `unavailable` с `Retry-After` — недоступность зависимости не маскируется под 500. `/health/live` отвечает 200, пока жив процесс; `/health/ready` выполняет `SELECT 1` с отдельным лимитом и отдаёт 503, если база недоступна. Valkey в readiness не входит сознательно: без кэша сервис работоспособен. Ошибки кэша считаются в счётчике и логируются не чаще одного раза на 50 отказов.
|
||||
|
||||
**Что перенесено из lab1:** структура приложения и обработка ошибок, единый формат `{"error":{code,message,request_id}}`, `X-Request-Id` в каждом ответе, строгая валидация полей и курсора, потоковое чтение тела с лимитом (413), лимит одновременных запросов (429), graceful shutdown по SIGTERM с режимом drain, запуск от uid 10001.
|
||||
|
||||
**Объявленные переходы относительно lab1:** `X-User-Id` больше не аутентифицирует — вместо него Bearer-сессия; состояние ушло из памяти процесса в PostgreSQL, поэтому требование «ровно один процесс API» снято; счётчики `MAX_USERS/MAX_CHATS/MAX_MESSAGES` из lab1 убраны — они требовали бы `COUNT(*)` на каждый запрос, их роль теперь выполняют том базы и квоты СУБД; `MAX_RSS_MB` сохранён, но по умолчанию выключен (`0`), так как данные больше не живут в памяти.
|
||||
|
||||
**Решения по инфраструктуре.** Образы закреплены по digest: `postgres:17.7-alpine@sha256:bb377b72…`, `valkey/valkey:8.1-alpine@sha256:081c2f5c…`. У Valkey политика `allkeys-lru` и нет томов — это допустимо именно потому, что это кэш, а не хранилище истины. Пароль PostgreSQL и строки подключения передаются docker secrets, в `environment` лежат только пути к файлам. Порт API опубликован на `127.0.0.1:8080`, внутрь контейнера сервер слушает `0.0.0.0` (иначе проброшенный порт не дошёл бы до процесса). CI (`.github/workflows/app.yml`) поднимает стек, проверяет повторный запуск миграций и гоняет smoke, свои тесты и persistence.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
Окружение: Apple M4, 10 ядер, 16 ГБ RAM, Docker Desktop (лимит 10 CPU / 7.7 ГБ), macOS Darwin 25.6.0 arm64, Docker 29.7.2, Compose v5.5.1, PostgreSQL 17.7 (aarch64, musl), Valkey 8.1.10, образ API — python 3.12.8-slim, хост-Python 3.9.6, 2026-10-19. Полный состав стенда и версии — в `evidence/stand.txt`. Все числа ниже получены одним прогоном `make evidence`, начатым с удаления тома базы, поэтому относятся к одному и тому же состоянию стенда.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` |
|
||||
| Данные и действующие сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (hook: `docker compose restart postgres valkey api`) | `PASS: persistence preserved confirmed data and existing session`; тот же токен читает ту же историю | `evidence/persistence.txt` (состояние контейнеров до и после, логи postgres о перезапуске) |
|
||||
| PostgreSQL содержит users/chats/members/messages, есть PK/FK, уникальность username, миграции с нуля | `make up` на пустом томе, затем `make migrate` | `apply 0001_init`, повторный запуск — `skip 0001_init`; в `schema_migrations` одна версия с checksum `4fd0a8c6…` | `evidence/migrations.txt` (включая `\d+ messages`) |
|
||||
| Составная операция создания чата атомарна | `test_storage_rules.py::unknown_member_rolls_chat_back` | 400 на неизвестного участника, чат в списке отсутствует | `evidence/level4-tests.txt` |
|
||||
| Basic только на `POST /auth/sessions`, остальное — Bearer; `X-User-Id` не даёт доступа | `test_auth_sessions.py` | 9/9 PASS, в том числе Basic на `/users/me` → 401 Bearer, вход с телом → 400, повреждённый UTF-8 → 400/401 | `evidence/level4-tests.txt` |
|
||||
| Срок жизни сессии и отзыв | `make expiry` (TTL=2 с) | 3/3 PASS: истёкший токен → 401, запись истёкшим → 401, `expires_at` соответствует TTL | `evidence/expiry.txt` |
|
||||
| Отозванная сессия не возвращается вместе с кэшом | `make outages` | 4/4 PASS; после 204 и `restart valkey` токен даёт 401 | `evidence/outages.txt` |
|
||||
| Пароли хешируются password KDF | `app/passwords.py`, формат хеша в БД | `$argon2id$v=19$m=19456,t=2,p=1$…`, в API пароль не возвращается | `evidence/level4-tests.txt` |
|
||||
| Любая строка Unicode сохраняется без искажений | `test_storage_rules.py::nul_and_unicode_text_round_trips`, `::text_length_limit_counts_code_points` | `a\u0000b`, одиночный `\u0000`, emoji с ZWJ, комбинирующие и RTL, 4000 code points — 201 и точный round-trip; 4001 — 400 | `evidence/level4-tests.txt` |
|
||||
| Secrets/volumes не попадают в Git | `git status --porcelain`, `git check-ignore -v` | `.env`, `secrets/`, `backups/` игнорируются; в рабочем дереве только код, тесты и `evidence/` | `evidence/git-hygiene.txt` |
|
||||
| Redis/Valkey реально используется для сессий с TTL | `tests/load.py` с кэшем и без него | 1097.7 RPS / p95 6.06 мс против 691.7 RPS / p95 8.15 мс, `failed_requests: 0` в обоих прогонах | `evidence/load-cache.json`, `evidence/load-nocache.json`, `evidence/load.txt` |
|
||||
| Параметризованные запросы, ограниченный пул и таймауты | `test_storage_rules.py::sql_injection_is_not_executed`, `::content_type_is_required`, `::broken_json_does_not_break_the_api`, `app/db.py` | SQL-пробы → 400, текст с кавычками сохраняется дословно, битый JSON → 400; пул 1..10, `statement_timeout=5000`, клиентский лимит 6 с, потолок запроса 8 с | `evidence/level4-tests.txt` |
|
||||
| Гонка регистрации одинакового username | `test_storage_rules.py::duplicate_username_race_creates_one_user` (12 потоков) | один 201, одиннадцать 409 | `evidence/level4-tests.txt` |
|
||||
| Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях, пагинация без полного скана | `make explain` (53 764 сообщения в таблице) | keyset, первая страница: 24 буфера, 0.026 мс; keyset на глубине 90 %: 53 буфера, 0.063 мс; OFFSET той же глубины: 29 813 буферов, 4.17 мс (29 699 строк пройдено ради 50) | `evidence/explain-10k.txt` |
|
||||
| Проверка expiry, logout, неверного пароля и недоступности Redis/БД | `make dependency`, `make outages` | без Valkey 3/3 PASS (кэш обойдён, ошибок нет); без PostgreSQL 4/4 PASS: `/health/ready` 503, запись 503, неизвестный токен не становится доверенным; зависшая БД (`pause`) отвечает 503 быстрее 10 с | `evidence/dependency.txt`, `evidence/outages.txt` |
|
||||
| Трек 5 (трек 2): ≥100 000 сообщений, ≥2 индекса, цена записи, backup → restore → сверка | `TOTAL=120000 make track2` | 120 000 сообщений в 68 чатах; варианты A/B/C сравнены; md5 истории источника и копии совпали; маркер после бэкапа в копии отсутствует | `evidence/track2/run.txt` |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
Проверка инфраструктурного hook: `scripts/restart.sh` выполняет `docker compose --env-file .env restart postgres valkey api`, то есть перезапускаются и API, и PostgreSQL, и Valkey; тома не удаляются. Подтверждение — состояние контейнеров до и после в `evidence/persistence.txt` (у всех трёх сервисов новое время старта) плюс строки `database system was shut down` → `database system is ready to accept connections` в логах postgres из того же файла.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
### Трек 2, часть 1: план запроса и цена индекса
|
||||
|
||||
**Гипотеза.** Для keyset-пагинации по контракту (`ORDER BY created_at, id` внутри одного чата) составной индекс `(chat_id, created_at, id)` даёт цену страницы, не зависящую от её глубины, а индекс только по `chat_id` вынуждает читать и сортировать всю историю чата на каждую страницу. Покрывающий индекс с `INCLUDE (sender_id, text)` должен убрать обращения к heap, но увеличить размер индекса и цену записи.
|
||||
|
||||
**Методика.** Стенд описан выше, PostgreSQL запущен с `shared_buffers=128MB`, `work_mem=8MB`, `track_io_timing=on`. Данные: `student-tests/seed.sql` добивает историю до заданного размера, распределяя сообщения по 50 чатам с перекосом `power(random(), 3)`; поверх лежат чаты публичного smoke, своих тестов и нагрузочных прогонов. В этом прогоне засев дописал 66 236 строк до ровно 120 000 сообщений в 68 чатах. Размеры чатов неравномерны: 32 944 строки в самом большом, 20 775 во втором, затем 25, 5 и 3 — то есть разброс в четыре порядка. Точка измерения — страница на глубине 90 % истории самого большого чата. Каждый вариант индекса создаётся внутри транзакции и откатывается (`BEGIN … ROLLBACK`), поэтому рабочая схема не меняется и порядок вариантов не влияет на результат. Для каждого варианта снимаются: план `EXPLAIN (ANALYZE, BUFFERS)` одной страницы, время 100 последовательных страниц с разными курсорами (коррелированный `LATERAL`: без зависимости от номера итерации планировщик выполняет подзапрос один раз и измерение обнуляется — так и произошло в первой версии скрипта), размер индекса и время вставки 10 000 строк при этом наборе индексов. Прогрев: засев и `ANALYZE` выполняются до измерений, кэш БД тёплый.
|
||||
|
||||
| Вариант индекса | План страницы на глубине 90 % | Буферы | Время одной страницы | 100 страниц | Размер индекса | Вставка 10 000 строк |
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
| A `(chat_id, created_at, id)` — рабочий | `Index Scan using messages_history_idx` | 53 | 0.048 мс | 1.12 мс | 10 МБ | 0.084 с |
|
||||
| B `(chat_id)` | `Bitmap Heap Scan` + `Sort`, `Rows Removed by Filter: 29 650` | 441 | 1.73 мс | 2186 мс | 848 кБ | 0.078 с |
|
||||
| C `(chat_id, created_at, id) INCLUDE (sender_id, text)` | `Index Only Scan`, `Heap Fetches: 0` | 4 | 0.031 мс | 0.74 мс | 14 МБ | 0.085 с |
|
||||
|
||||
**Что наблюдали.** Вариант B на каждой странице поднимает из heap почти весь чат и отбрасывает фильтром 29 650 строк ради 50 нужных; на серии из 100 страниц он медленнее A примерно в 1950 раз (2186 мс против 1.12 мс), причём отставание растёт вместе с размером чата, а не фиксировано. Вариант C не ходит в heap вообще (`Heap Fetches: 0`, 4 буфера против 53) и на серии страниц быстрее A примерно на треть, платя 14 МБ индекса против 10 МБ. Ожидаемого удорожания записи у C на этих данных не видно: 0.085 с против 0.084 с на 10 000 строк — разница в пределах шума, потому что засеянные тексты короткие и однотипные. B пишет быстрее всех (0.078 с) просто потому, что его индекс меньше.
|
||||
|
||||
**Вывод.** В схему взят вариант A: постоянная цена страницы при умеренном размере индекса. C даёт измеримый выигрыш по буферам и по серии страниц и остаётся кандидатом, если история читается существенно чаще, чем пишется; прежде чем переключаться, его цену записи нужно перемерять на длинных текстах, где дублирование текста в индексе должно проявиться. Переключение — одна миграция.
|
||||
|
||||
### Трек 2, часть 2: бэкап и восстановление в новое хранилище
|
||||
|
||||
**Гипотеза.** `pg_dump -Fc` даёт согласованный снимок на момент начала дампа; восстановление в чистое хранилище воспроизводит данные точно, а всё подтверждённое после снимка теряется — это и есть граница потери данных при такой схеме бэкапа.
|
||||
|
||||
**Методика.** `student-tests/track2.sh`: снимок `pg_dump -Fc` → запись маркерного сообщения уже после дампа → поднятие отдельного контейнера PostgreSQL 17.7 на новом томе `mtusi-lab2-restore-data` с новой базой `messenger_restored` → `pg_restore --exit-on-error` → сверка. Сверяются количество строк в каждой таблице, количество строк и md5 конкатенации `(id, created_at, encode(text,'hex'))` в порядке `(created_at, id)` для самого большого чата, первые три сообщения этого чата и наличие маркера. Сверка идёт по `encode`, а не по `convert_from`, потому что в истории есть сообщения с реальным NUL — на них перевод bytea в text падает. Время бэкапа и восстановления снимается внешним таймером с точностью до миллисекунды и включает накладные расходы `docker exec`.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `pg_dump -Fc` базы с 120 000 сообщений | согласованный дамп | файл 5.6 МБ | бэкап 0.761 с |
|
||||
| `pg_restore` в новый том и новую базу | совпадение количества и содержимого | users 74/74, chats 68/68, chat_members 1036/1036, messages 120 000/120 000, sessions 43/43; md5 истории большого чата (32 944 строки) `6c6725a76404fbb0b8b5b509707e30b5` в обеих базах; первые три сообщения совпали | восстановление 0.370 с; потерь на момент снимка нет |
|
||||
| Запись после снимка (маркерное сообщение) | в копии отсутствует | в источнике 1 маркер, в восстановленной копии 0 | потеряно всё, подтверждённое после начала дампа |
|
||||
| Рестарт API и обоих хранилищ с сохранением томов | данные и действующая сессия живы | `PASS` публичного persistence-теста: тот же токен читает ту же историю, дублей нет | простой до readiness < 10 с, потерь нет |
|
||||
| Остановка Valkey под нагрузкой | кэш обходится, ошибок нет | 691.7 RPS против 1097.7 RPS, p95 8.15 мс против 6.06 мс, `failed_requests: 0` | потерь нет, деградация по скорости ×1.6 |
|
||||
| Остановка PostgreSQL | ограниченная ошибка, доверия нет | `/health/ready` 503, регистрация 503, неизвестный токен → 503/401, анонимный → 401, `/health/live` 200 | запись недоступна полностью до возврата БД |
|
||||
| Заморозка PostgreSQL (`docker compose pause`) | быстрый 503, а не зависший запрос | 503 быстрее 10 с при потолке запроса 8 с; после `unpause` доступ восстановился | потерь нет |
|
||||
| Рестарт Valkey после подтверждённого logout | отозванный токен остаётся мёртвым | 401 после рестарта кэша | потерь нет |
|
||||
|
||||
**Нагрузочный профиль** (для контекста, не доказательство ёмкости): `tests/load.py`, closed loop, concurrency 4, длительность 30 с, по одному прогону на точку. С кэшем: 32 944 успешных POST, 0 ошибок, 1097.706 RPS, p50 3.248 / p95 6.063 / p99 10.603 мс. С остановленным Valkey: 20 775 успешных POST, 0 ошибок, 691.741 RPS, p50 5.447 / p95 8.152 / p99 11.778 мс. Разница — цена похода в PostgreSQL за сессией на каждом запросе; ноль ошибок в обоих прогонах показывает, что отказ кэша обходится, а не ломает запись. Это пропускная способность HTTP-подтверждений, а не счётчик COMMIT: закрытый контур страдает coordinated omission, клиент и сервер работают на одной машине, поэтому абсолютные числа занижены относительно отдельного стенда.
|
||||
|
||||
**Ограничения измерений.** Всё измерено на одной машине, с тёплым кэшом БД, по одному прогону на точку, без фиксации частоты CPU и без контроля троттлинга; потребление CPU и RAM по контейнерам не снималось. Размер индекса измеряется внутри откатываемой транзакции, поэтому при повторных запусках скрипта к индексу добавляются мёртвые записи до `VACUUM` — сравнивать размеры корректно только внутри одного прогона. Два самых больших чата сформированы нагрузочными прогонами, поэтому тексты в них короткие и однотипные: на длинных текстах разрыв между A и C по размеру индекса и цене записи будет больше. Прогон без кэша выполнялся на уже подросшей таблице, поэтому отношение RPS показывает направление и порядок эффекта, а не точный коэффициент. Числа p50/p95/p99 относятся только к успешным запросам.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
**Какие отказы выдерживаются.** Перезапуск API, PostgreSQL и Valkey с сохранением томов: подтверждённые данные и ещё действующие сессии остаются, TTL не продлевается, а уже отозванные сессии не оживают. Полная потеря Valkey: сервис продолжает работать, читая сессии из PostgreSQL, цена — падение пропускной способности примерно в 1.7 раза. Потеря соединения с БД: запросы получают 503 с `Retry-After`, пул переподключается сам, readiness честно показывает недоступность. Заморозка БД: клиентский лимит и потолок запроса не дают запросу зависнуть.
|
||||
|
||||
**Какие отказы не выдерживаются.** PostgreSQL — единственная точка истины без реплики: при потере тома `pgdata` данные восстанавливаются только из дампа, то есть теряется всё после последнего `pg_dump`. WAL-архивирование и PITR не настроены, непрерывного бэкапа нет. API — один экземпляр, балансировщика нет (это тема lab3), поэтому его перезапуск — простой сервиса, а не бесшовное переключение. Rate limiting по пользователю и HTTPS в объём lab2 не входят.
|
||||
|
||||
**Учебные упрощения.** Кэш сессий намеренно volatile: это снимает риск воскрешения отозванной сессии, но после каждого рестарта Valkey первые запросы идут в базу. Logout при недоступном кэше возвращает 503 и не отзывает сессию — выход нужно повторить; альтернатива (удалить строку в БД и надеяться, что кэш очистится) давала бы окно, в котором мёртвый токен работает. Параметры Argon2id (19 МБ, t=2, p=1) выбраны по RFC 9106 как второй рекомендуемый профиль и снижены относительно умолчаний библиотеки (64 МБ), чтобы одновременные входы не съедали память контейнера. Хранение текста в `bytea` усложняет SQL-запросы к этим столбцам — это осознанная цена за точный round-trip Unicode. Данные экспериментов (`load_*` пользователи, `load chat *`) лежат в той же базе, что и smoke-данные: отдельного стенда для экспериментов нет, поэтому два самых больших чата в выборке — это чаты нагрузочных прогонов.
|
||||
|
||||
**Что подтверждено, а что пока гипотеза.** Подтверждено измерениями: постоянная цена keyset-страницы на 120 тысячах сообщений, деградация варианта B на глубине примерно в 1950 раз, выигрыш покрывающего индекса по буферам (4 против 53) и по серии страниц, выигрыш кэша сессий по RPS и p95 при нулевом числе ошибок, полное совпадение восстановленной копии с источником и отсутствие в ней записей, подтверждённых после снимка, корректная деградация при остановке и при заморозке каждого из хранилищ, устойчивость отзыва сессии к рестарту кэша. Гипотезы, не проверенные здесь: что покрывающий индекс C дороже в записи — на этих данных разница с A укладывается в шум (0.085 с против 0.084 с), и проверять это нужно на текстах, близких к 4000 символов; что C окажется выгоднее на холодном кэше и при большом числе параллельных читателей; что `max_size=10` в пуле — оптимум (значение взято с запасом под `max_connections=50`, но под нагрузкой не подбиралось).
|
||||
|
||||
**Следующие шаги.** Настроить WAL-архивирование и проверить PITR с восстановлением на момент времени; добавить реплику PostgreSQL и измерить переключение; подобрать `DB_POOL_MAX` и профиль Argon2id под целевой p95; перенести эксперименты на отдельную базу; в lab3 добавить балансировщик и идемпотентность записи.
|
||||
|
||||
## Ответы на вопросы защиты
|
||||
|
||||
- **Что подтверждает COMMIT и от какой настройки durability это зависит.** COMMIT подтверждает, что изменения записаны в WAL и сброшены на диск, поэтому после аварии они будут восстановлены. Зависит от `synchronous_commit` (у нас `on`) и `fsync` (включён): при `synchronous_commit=off` ответ клиенту приходит раньше фактического fsync, и последние транзакции можно потерять при потере питания.
|
||||
- **Где хранятся сессии и что будет после flush/restart Valkey.** Источник истины — таблица `sessions` в PostgreSQL; в Valkey только кэш с TTL и без persistence. После `FLUSHALL` или рестарта Valkey сессии продолжают работать: первый запрос промахивается, читает строку из базы и снова наполняет кэш. Важнее обратное: именно потому, что кэш не переживает рестарт, отозванная сессия не может вернуться вместе с кэшом — это проверено тестом.
|
||||
- **Чем аутентификация отличается от доступа к конкретному чату.** Аутентификация отвечает на вопрос «кто это»: действителен ли Bearer-токен и не истёк ли он; её провал — 401. Доступ отвечает на вопрос «можно ли этому пользователю именно этот чат»: есть ли строка в `chat_members`; её провал — 404, а не 403, чтобы не раскрывать существование чужого чата.
|
||||
- **Почему hash пароля и быстрый checksum решают разные задачи.** Пароль человек выбирает из небольшого множества, поэтому его хеш должен быть намеренно медленным и требовательным к памяти (Argon2id), чтобы перебор был дорогим. Токен сессии — 256 случайных бит, перебирать его бессмысленно, поэтому для него достаточно быстрого SHA-256: он нужен лишь для того, чтобы в базе не лежал сам токен и утечка таблицы не давала доступа.
|
||||
- **Почему текст лежит в `bytea`, а не в `text`.** Потому что контракт разрешает любые Unicode code points, а `text` в PostgreSQL не может содержать U+0000: такой запрос либо падает с 500, либо строку приходится молча портить. Байты сохраняют её точно, а длину в code points проверяет приложение.
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
import os
|
||||
import socket
|
||||
|
||||
|
||||
def _int(name, default):
|
||||
value = os.environ.get(name)
|
||||
return int(value) if value not in (None, "") else default
|
||||
|
||||
|
||||
def _float(name, default):
|
||||
value = os.environ.get(name)
|
||||
return float(value) if value not in (None, "") else default
|
||||
|
||||
|
||||
def _secret(name, default=""):
|
||||
path = os.environ.get(name + "_FILE")
|
||||
if path:
|
||||
with open(path, encoding="utf-8") as handle:
|
||||
return handle.read().strip()
|
||||
return os.environ.get(name, default)
|
||||
|
||||
|
||||
DATABASE_URL = _secret("DATABASE_URL")
|
||||
CACHE_URL = _secret("CACHE_URL")
|
||||
SESSION_STORE = os.environ.get("SESSION_STORE", "postgres")
|
||||
SESSION_TTL_SECONDS = _int("SESSION_TTL_SECONDS", 3600)
|
||||
SESSION_CACHE_TTL_SECONDS = _int("SESSION_CACHE_TTL_SECONDS", 30)
|
||||
SESSION_SWEEP_SECONDS = _int("SESSION_SWEEP_SECONDS", 60)
|
||||
DB_POOL_MIN = _int("DB_POOL_MIN", 1)
|
||||
DB_POOL_MAX = _int("DB_POOL_MAX", 10)
|
||||
DB_POOL_TIMEOUT = _float("DB_POOL_TIMEOUT", 3.0)
|
||||
DB_CONNECT_TIMEOUT = _int("DB_CONNECT_TIMEOUT", 3)
|
||||
DB_STATEMENT_TIMEOUT_MS = _int("DB_STATEMENT_TIMEOUT_MS", 5000)
|
||||
DB_OP_TIMEOUT = _float("DB_OP_TIMEOUT", 6.0)
|
||||
REQUEST_TIMEOUT = _float("REQUEST_TIMEOUT", 8.0)
|
||||
DB_READY_TIMEOUT = _float("DB_READY_TIMEOUT", 1.5)
|
||||
CACHE_TIMEOUT = _float("CACHE_TIMEOUT", 0.2)
|
||||
MAX_INFLIGHT_REQUESTS = _int("MAX_INFLIGHT_REQUESTS", 64)
|
||||
MAX_BODY_BYTES = _int("MAX_BODY_BYTES", 65536)
|
||||
MAX_RSS_MB = _int("MAX_RSS_MB", 0)
|
||||
PASSWORD_MIN = 12
|
||||
PASSWORD_MAX = 128
|
||||
INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname()
|
||||
@@ -0,0 +1,43 @@
|
||||
import base64
|
||||
import json
|
||||
import re
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
|
||||
TS_RE = re.compile(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z")
|
||||
TS_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
|
||||
|
||||
|
||||
class BadCursor(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def fmt(ts: datetime) -> str:
|
||||
return ts.astimezone(timezone.utc).strftime(TS_FORMAT)
|
||||
|
||||
|
||||
def encode_cursor(scope: str, created_at: str, item_id: str) -> str:
|
||||
raw = json.dumps({"s": scope, "t": created_at, "i": item_id}, separators=(",", ":")).encode()
|
||||
return base64.urlsafe_b64encode(raw).decode().rstrip("=")
|
||||
|
||||
|
||||
def decode_cursor(scope: str, cursor: str):
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4))
|
||||
data = json.loads(raw)
|
||||
except Exception:
|
||||
raise BadCursor() from None
|
||||
if not isinstance(data, dict) or set(data) != {"s", "t", "i"} or data["s"] != scope:
|
||||
raise BadCursor()
|
||||
ts, item_id = data["t"], data["i"]
|
||||
if not isinstance(ts, str) or not TS_RE.fullmatch(ts) or not isinstance(item_id, str):
|
||||
raise BadCursor()
|
||||
try:
|
||||
parsed = datetime.strptime(ts, TS_FORMAT).replace(tzinfo=timezone.utc)
|
||||
if str(uuid.UUID(item_id)) != item_id:
|
||||
raise BadCursor()
|
||||
except ValueError:
|
||||
raise BadCursor() from None
|
||||
if encode_cursor(scope, ts, item_id) != cursor:
|
||||
raise BadCursor()
|
||||
return parsed, item_id
|
||||
@@ -0,0 +1,99 @@
|
||||
import asyncio
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import AsyncConnectionPool, PoolTimeout
|
||||
|
||||
from app import config
|
||||
from app.errors import unavailable
|
||||
|
||||
BROKEN = (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout)
|
||||
|
||||
|
||||
async def discard(conn) -> None:
|
||||
try:
|
||||
await conn.close()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
class Guarded:
|
||||
def __init__(self, conn, timeout: float):
|
||||
self.conn = conn
|
||||
self.timeout = timeout
|
||||
|
||||
async def execute(self, *args, **kwargs):
|
||||
try:
|
||||
return await asyncio.wait_for(self.conn.execute(*args, **kwargs), self.timeout)
|
||||
except asyncio.TimeoutError:
|
||||
await discard(self.conn)
|
||||
raise unavailable("Хранилище не ответило за отведённое время") from None
|
||||
|
||||
def transaction(self):
|
||||
return self.conn.transaction()
|
||||
|
||||
|
||||
class Database:
|
||||
def __init__(self) -> None:
|
||||
options = "-c statement_timeout=%d -c lock_timeout=%d -c idle_in_transaction_session_timeout=%d" % (
|
||||
config.DB_STATEMENT_TIMEOUT_MS,
|
||||
config.DB_STATEMENT_TIMEOUT_MS,
|
||||
config.DB_STATEMENT_TIMEOUT_MS * 2,
|
||||
)
|
||||
self.pool = AsyncConnectionPool(
|
||||
conninfo=config.DATABASE_URL,
|
||||
min_size=config.DB_POOL_MIN,
|
||||
max_size=config.DB_POOL_MAX,
|
||||
timeout=config.DB_POOL_TIMEOUT,
|
||||
max_lifetime=600.0,
|
||||
open=False,
|
||||
kwargs={
|
||||
"autocommit": True,
|
||||
"row_factory": dict_row,
|
||||
"connect_timeout": config.DB_CONNECT_TIMEOUT,
|
||||
"options": options,
|
||||
},
|
||||
)
|
||||
|
||||
async def open(self) -> None:
|
||||
await self.pool.open(wait=False)
|
||||
|
||||
async def close(self) -> None:
|
||||
await self.pool.close()
|
||||
|
||||
@asynccontextmanager
|
||||
async def connection(self):
|
||||
try:
|
||||
async with self.pool.connection(timeout=config.DB_POOL_TIMEOUT) as conn:
|
||||
yield Guarded(conn, config.DB_OP_TIMEOUT)
|
||||
except BROKEN:
|
||||
raise unavailable("Хранилище недоступно") from None
|
||||
|
||||
@asynccontextmanager
|
||||
async def transaction(self):
|
||||
async with self.connection() as conn:
|
||||
async with conn.transaction():
|
||||
yield conn
|
||||
|
||||
async def in_transaction(self, action):
|
||||
async def run():
|
||||
async with self.transaction() as conn:
|
||||
return await action(conn)
|
||||
|
||||
try:
|
||||
return await asyncio.wait_for(run(), config.DB_OP_TIMEOUT)
|
||||
except asyncio.TimeoutError:
|
||||
raise unavailable("Хранилище не ответило за отведённое время") from None
|
||||
|
||||
async def ready(self) -> bool:
|
||||
try:
|
||||
async with self.pool.connection(timeout=config.DB_READY_TIMEOUT) as conn:
|
||||
try:
|
||||
await asyncio.wait_for(conn.execute("SELECT 1"), config.DB_READY_TIMEOUT)
|
||||
except asyncio.TimeoutError:
|
||||
await discard(conn)
|
||||
return False
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
@@ -0,0 +1,37 @@
|
||||
from typing import Optional
|
||||
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status: int, code: str, message: str, headers: Optional[dict] = None):
|
||||
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
|
||||
|
||||
|
||||
def bad(message: str) -> ApiError:
|
||||
return ApiError(400, "invalid_request", message)
|
||||
|
||||
|
||||
def unauthorized(scheme: str = "Bearer") -> ApiError:
|
||||
challenge = BASIC_CHALLENGE if scheme == "Basic" else BEARER_CHALLENGE
|
||||
message = "Нужны имя пользователя и пароль" if scheme == "Basic" else "Нужна действующая сессия"
|
||||
return ApiError(401, "unauthorized", message, {"WWW-Authenticate": challenge})
|
||||
|
||||
|
||||
def not_found() -> ApiError:
|
||||
return ApiError(404, "not_found", "Объект не найден")
|
||||
|
||||
|
||||
def unavailable(message: str) -> ApiError:
|
||||
return ApiError(503, "unavailable", message, {"Retry-After": "1"})
|
||||
|
||||
|
||||
def error_body(rid: str, instance: str, status: int, code: str, message: str, headers: Optional[dict] = None) -> JSONResponse:
|
||||
return JSONResponse(
|
||||
status_code=status,
|
||||
content={"error": {"code": code, "message": message, "request_id": rid}},
|
||||
headers={"X-Request-Id": rid, "X-Instance-Id": instance, **(headers or {})},
|
||||
)
|
||||
+391
@@ -0,0 +1,391 @@
|
||||
import asyncio
|
||||
import base64
|
||||
import binascii
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import resource
|
||||
import signal
|
||||
import sys
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
|
||||
from app import config, passwords, repo
|
||||
from app.cursor import BadCursor, decode_cursor, encode_cursor
|
||||
from app.db import Database
|
||||
from app.errors import ApiError, bad, error_body, not_found, unauthorized, unavailable
|
||||
from app.sessions import SessionStore
|
||||
|
||||
logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
||||
log = logging.getLogger("messenger")
|
||||
|
||||
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
|
||||
ZERO_WIDTH = str.maketrans({char: None for char in "\u200b\u200c\u200d\u2060\ufeff"})
|
||||
EXEMPT_PATHS = ("/health/live", "/health/ready")
|
||||
PAGE_SIZE = os.sysconf("SC_PAGE_SIZE") if hasattr(os, "sysconf") else 4096
|
||||
|
||||
db = Database()
|
||||
sessions = SessionStore(db)
|
||||
state = {"draining": False, "inflight": 0, "rejected": {}}
|
||||
|
||||
|
||||
def rss_mb() -> float:
|
||||
try:
|
||||
with open("/proc/self/statm") as handle:
|
||||
return int(handle.read().split()[1]) * PAGE_SIZE / 1048576
|
||||
except OSError:
|
||||
peak = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
|
||||
return peak / 1048576 if sys.platform == "darwin" else peak / 1024
|
||||
|
||||
|
||||
def count_rejection(code: str) -> None:
|
||||
state["rejected"][code] = state["rejected"].get(code, 0) + 1
|
||||
|
||||
|
||||
async def sweeper() -> None:
|
||||
while True:
|
||||
await asyncio.sleep(config.SESSION_SWEEP_SECONDS)
|
||||
try:
|
||||
removed = await sessions.sweep()
|
||||
if removed:
|
||||
log.info("sessions_expired removed=%d", removed)
|
||||
except Exception:
|
||||
log.warning("session sweep skipped: storage unavailable")
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_app: FastAPI):
|
||||
previous = {}
|
||||
|
||||
def on_signal(signum, frame):
|
||||
if not state["draining"]:
|
||||
state["draining"] = True
|
||||
log.info("signal %s: draining, new requests get 503", signal.Signals(signum).name)
|
||||
handler = previous.get(signum)
|
||||
if callable(handler):
|
||||
handler(signum, frame)
|
||||
|
||||
for sig in (signal.SIGTERM, signal.SIGINT):
|
||||
previous[sig] = signal.getsignal(sig)
|
||||
signal.signal(sig, on_signal)
|
||||
await db.open()
|
||||
await sessions.open()
|
||||
task = asyncio.create_task(sweeper())
|
||||
log.info(
|
||||
"started: instance=%s session_store=%s session_ttl=%d cache_ttl=%d pool=%d..%d max_inflight=%d max_body=%d",
|
||||
config.INSTANCE_ID, config.SESSION_STORE, config.SESSION_TTL_SECONDS, config.SESSION_CACHE_TTL_SECONDS,
|
||||
config.DB_POOL_MIN, config.DB_POOL_MAX, config.MAX_INFLIGHT_REQUESTS, config.MAX_BODY_BYTES,
|
||||
)
|
||||
yield
|
||||
task.cancel()
|
||||
await sessions.close()
|
||||
await db.close()
|
||||
log.info("stopped: cache=%s rejected=%s", sessions.stats, state["rejected"])
|
||||
|
||||
|
||||
app = FastAPI(lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def guard(request: Request, call_next):
|
||||
rid = uuid.uuid4().hex
|
||||
request.state.rid = rid
|
||||
exempt = request.url.path in EXEMPT_PATHS
|
||||
if state["draining"] and request.url.path != "/health/live":
|
||||
count_rejection("draining")
|
||||
return error_body(rid, config.INSTANCE_ID, 503, "unavailable", "Сервер завершает работу", {"Retry-After": "1", "Connection": "close"})
|
||||
if not exempt and state["inflight"] >= config.MAX_INFLIGHT_REQUESTS:
|
||||
count_rejection("inflight")
|
||||
return error_body(rid, config.INSTANCE_ID, 429, "rate_limited", "Слишком много одновременных запросов", {"Retry-After": "1"})
|
||||
state["inflight"] += 1
|
||||
try:
|
||||
response = await asyncio.wait_for(call_next(request), config.REQUEST_TIMEOUT)
|
||||
except asyncio.TimeoutError:
|
||||
count_rejection("request_timeout")
|
||||
log.warning("request timeout request_id=%s method=%s path=%s", rid, request.method, request.url.path)
|
||||
response = error_body(
|
||||
rid, config.INSTANCE_ID, 503, "unavailable",
|
||||
"Запрос не удалось обработать за отведённое время", {"Retry-After": "1"},
|
||||
)
|
||||
except Exception:
|
||||
log.exception("unhandled error request_id=%s", rid)
|
||||
response = error_body(rid, config.INSTANCE_ID, 500, "internal_error", "Внутренняя ошибка сервера")
|
||||
finally:
|
||||
state["inflight"] -= 1
|
||||
response.headers["X-Request-Id"] = rid
|
||||
response.headers["X-Instance-Id"] = config.INSTANCE_ID
|
||||
return response
|
||||
|
||||
|
||||
@app.exception_handler(ApiError)
|
||||
async def api_error_handler(request: Request, exc: ApiError):
|
||||
if exc.status in (413, 429, 503):
|
||||
count_rejection(exc.code)
|
||||
return error_body(request.state.rid, config.INSTANCE_ID, exc.status, exc.code, exc.message, exc.headers)
|
||||
|
||||
|
||||
def parse_uuid(value: object) -> Optional[str]:
|
||||
if not isinstance(value, str):
|
||||
return None
|
||||
try:
|
||||
return str(uuid.UUID(value))
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def non_blank(value: object, max_len: int) -> bool:
|
||||
if not isinstance(value, str) or not 1 <= len(value) <= max_len:
|
||||
return False
|
||||
return value.translate(ZERO_WIDTH).strip() != ""
|
||||
|
||||
|
||||
async def read_json(request: Request, fields: Tuple[str, ...]) -> dict:
|
||||
if request.headers.get("content-type", "").split(";")[0].strip().lower() != "application/json":
|
||||
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
|
||||
too_large = ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"Connection": "close"})
|
||||
declared = request.headers.get("content-length")
|
||||
if declared and declared.isdigit() and int(declared) > config.MAX_BODY_BYTES:
|
||||
raise too_large
|
||||
raw = bytearray()
|
||||
async for chunk in request.stream():
|
||||
raw += chunk
|
||||
if len(raw) > config.MAX_BODY_BYTES:
|
||||
raise too_large
|
||||
try:
|
||||
body = json.loads(bytes(raw).decode("utf-8"))
|
||||
except (UnicodeDecodeError, ValueError, RecursionError):
|
||||
raise bad("Некорректный JSON") from None
|
||||
if not isinstance(body, dict):
|
||||
raise bad("Ожидается JSON-объект")
|
||||
if set(body) - set(fields):
|
||||
raise bad("Лишние поля в запросе")
|
||||
if set(fields) - set(body):
|
||||
raise bad("Отсутствуют обязательные поля")
|
||||
return body
|
||||
|
||||
|
||||
def ensure_capacity() -> None:
|
||||
if config.MAX_RSS_MB and rss_mb() > config.MAX_RSS_MB:
|
||||
raise unavailable("Достигнут лимит памяти процесса, запись недоступна")
|
||||
|
||||
|
||||
def bearer_token(request: Request) -> str:
|
||||
scheme, _, value = request.headers.get("authorization", "").partition(" ")
|
||||
token = value.strip()
|
||||
if scheme.lower() != "bearer" or not token:
|
||||
raise unauthorized()
|
||||
return token
|
||||
|
||||
|
||||
async def actor(request: Request) -> dict:
|
||||
user = await sessions.resolve(bearer_token(request))
|
||||
if user is None:
|
||||
raise unauthorized()
|
||||
return user
|
||||
|
||||
|
||||
def basic_credentials(request: Request) -> Tuple[str, str]:
|
||||
scheme, _, value = request.headers.get("authorization", "").partition(" ")
|
||||
if scheme.lower() != "basic" or not value.strip():
|
||||
raise unauthorized("Basic")
|
||||
try:
|
||||
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
|
||||
except (binascii.Error, ValueError, UnicodeDecodeError):
|
||||
raise unauthorized("Basic") from None
|
||||
username, separator, password = decoded.partition(":")
|
||||
if not separator:
|
||||
raise unauthorized("Basic")
|
||||
return username, password
|
||||
|
||||
|
||||
async def member_chat(user: dict, chat_id: str) -> dict:
|
||||
cid = parse_uuid(chat_id)
|
||||
if cid is None:
|
||||
raise bad("chat_id должен быть UUID")
|
||||
async with db.connection() as conn:
|
||||
chat = await repo.chat_for_member(conn, cid, user["id"])
|
||||
if chat is None:
|
||||
raise not_found()
|
||||
return chat
|
||||
|
||||
|
||||
def page_params(request: Request) -> Tuple[int, Optional[str]]:
|
||||
query = request.query_params
|
||||
limit = 50
|
||||
if "limit" in query:
|
||||
if not re.fullmatch(r"[0-9]{1,3}", query["limit"]) or not 1 <= int(query["limit"]) <= 100:
|
||||
raise bad("limit должен быть целым 1..100")
|
||||
limit = int(query["limit"])
|
||||
cursor = query.get("cursor")
|
||||
if cursor is not None and cursor == "":
|
||||
raise bad("Некорректный cursor")
|
||||
return limit, cursor
|
||||
|
||||
|
||||
def keyset(scope: str, cursor: Optional[str]):
|
||||
if cursor is None:
|
||||
return None
|
||||
try:
|
||||
return decode_cursor(scope, cursor)
|
||||
except BadCursor:
|
||||
raise bad("Некорректный cursor") from None
|
||||
|
||||
|
||||
def page(scope: str, items: List[dict], has_more: bool) -> JSONResponse:
|
||||
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more and items else None
|
||||
return JSONResponse({"items": items, "next_cursor": next_cursor})
|
||||
|
||||
|
||||
@app.get("/health/live")
|
||||
async def live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
async def ready():
|
||||
if not await db.ready():
|
||||
raise unavailable("База данных недоступна")
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
async def create_user(request: Request):
|
||||
body = await read_json(request, ("username", "display_name", "password"))
|
||||
if not isinstance(body["username"], str) or not USERNAME_RE.fullmatch(body["username"]):
|
||||
raise bad("username должен соответствовать [a-z0-9_]{3,32}")
|
||||
if not non_blank(body["display_name"], 100):
|
||||
raise bad("display_name: 1..100 символов, не только пробелы")
|
||||
password = body["password"]
|
||||
if not isinstance(password, str) or not config.PASSWORD_MIN <= len(password) <= config.PASSWORD_MAX:
|
||||
raise bad("password: %d..%d символов" % (config.PASSWORD_MIN, config.PASSWORD_MAX))
|
||||
ensure_capacity()
|
||||
password_hash = await run_in_threadpool(passwords.hash_password, password)
|
||||
async with db.connection() as conn:
|
||||
user = await repo.create_user(conn, body["username"], body["display_name"], password_hash)
|
||||
if user is None:
|
||||
raise ApiError(409, "conflict", "username уже занят")
|
||||
log.info("user_created id=%s", user["id"])
|
||||
return JSONResponse(user, status_code=201)
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
async def login(request: Request):
|
||||
if await request.body():
|
||||
raise bad("POST /auth/sessions не принимает тело запроса")
|
||||
username, password = basic_credentials(request)
|
||||
row = None
|
||||
if USERNAME_RE.fullmatch(username) and config.PASSWORD_MIN <= len(password) <= config.PASSWORD_MAX:
|
||||
async with db.connection() as conn:
|
||||
row = await repo.credentials(conn, username)
|
||||
stored = row["password_hash"] if row else passwords.DUMMY_HASH
|
||||
matches = await run_in_threadpool(passwords.verify_password, stored, password)
|
||||
if row is None or not matches:
|
||||
log.info("login_failed username_known=%s", row is not None)
|
||||
raise unauthorized("Basic")
|
||||
user = repo.public_user(row)
|
||||
token, expires_at = await sessions.create(user)
|
||||
log.info("session_created user=%s", user["id"])
|
||||
return JSONResponse({"token": token, "token_type": "Bearer", "expires_at": expires_at, "user": user}, status_code=201)
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
async def logout(request: Request):
|
||||
token = bearer_token(request)
|
||||
user = await sessions.resolve(token)
|
||||
if user is None:
|
||||
raise unauthorized()
|
||||
await sessions.revoke(token)
|
||||
log.info("session_revoked user=%s", user["id"])
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
async def me(request: Request):
|
||||
return await actor(request)
|
||||
|
||||
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
async def create_chat(request: Request):
|
||||
user = await actor(request)
|
||||
body = await read_json(request, ("title", "member_ids"))
|
||||
if not non_blank(body["title"], 100):
|
||||
raise bad("title: 1..100 символов, не только пробелы")
|
||||
raw_ids = body["member_ids"]
|
||||
if not isinstance(raw_ids, list) or not 1 <= len(raw_ids) <= 100:
|
||||
raise bad("member_ids: массив из 1..100 UUID")
|
||||
ids: List[str] = []
|
||||
for value in raw_ids:
|
||||
parsed = parse_uuid(value)
|
||||
if parsed is None:
|
||||
raise bad("member_ids содержит некорректный UUID")
|
||||
ids.append(parsed)
|
||||
if len(set(ids)) != len(ids):
|
||||
raise bad("member_ids содержит дубликаты")
|
||||
if user["id"] not in ids:
|
||||
raise bad("Создатель должен входить в member_ids")
|
||||
ensure_capacity()
|
||||
|
||||
async def insert(conn):
|
||||
return await repo.create_chat(conn, body["title"], ids)
|
||||
|
||||
try:
|
||||
chat = await db.in_transaction(insert)
|
||||
except repo.UnknownMember:
|
||||
raise bad("member_ids содержит неизвестного пользователя") from None
|
||||
log.info("chat_created id=%s members=%d", chat["id"], len(ids))
|
||||
return JSONResponse(chat, status_code=201)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats")
|
||||
async def list_chats(request: Request):
|
||||
user = await actor(request)
|
||||
limit, cursor = page_params(request)
|
||||
scope = "chats:" + user["id"]
|
||||
after = keyset(scope, cursor)
|
||||
async with db.connection() as conn:
|
||||
items, has_more = await repo.list_chats(conn, user["id"], limit, after)
|
||||
return page(scope, items, has_more)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
async def get_chat(chat_id: str, request: Request):
|
||||
return await member_chat(await actor(request), chat_id)
|
||||
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
async def create_message(chat_id: str, request: Request):
|
||||
user = await actor(request)
|
||||
cid = parse_uuid(chat_id)
|
||||
if cid is None:
|
||||
raise bad("chat_id должен быть UUID")
|
||||
body = await read_json(request, ("text",))
|
||||
if not non_blank(body["text"], 4000):
|
||||
raise bad("text: 1..4000 символов, не только пробелы")
|
||||
ensure_capacity()
|
||||
async with db.connection() as conn:
|
||||
message = await repo.create_message(conn, cid, user["id"], body["text"])
|
||||
if message is None:
|
||||
raise not_found()
|
||||
return JSONResponse(message, status_code=201)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
async def list_messages(chat_id: str, request: Request):
|
||||
chat = await member_chat(await actor(request), chat_id)
|
||||
limit, cursor = page_params(request)
|
||||
scope = "messages:" + chat["id"]
|
||||
after = keyset(scope, cursor)
|
||||
async with db.connection() as conn:
|
||||
items, has_more = await repo.list_messages(conn, chat["id"], limit, after)
|
||||
return page(scope, items, has_more)
|
||||
|
||||
|
||||
@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE"])
|
||||
async def fallback(request: Request):
|
||||
raise not_found()
|
||||
@@ -0,0 +1,16 @@
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import Argon2Error, VerifyMismatchError
|
||||
|
||||
HASHER = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
|
||||
DUMMY_HASH = HASHER.hash("there-is-no-such-user-password")
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
return HASHER.hash(password)
|
||||
|
||||
|
||||
def verify_password(stored: str, password: str) -> bool:
|
||||
try:
|
||||
return HASHER.verify(stored, password)
|
||||
except (VerifyMismatchError, Argon2Error, ValueError):
|
||||
return False
|
||||
+132
@@ -0,0 +1,132 @@
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
import psycopg
|
||||
|
||||
from app.cursor import fmt
|
||||
|
||||
MESSAGE_COLUMNS = "id, chat_id, sender_id, text, created_at"
|
||||
CHAT_QUERY = (
|
||||
"SELECT c.id, c.title, c.created_at,"
|
||||
" ARRAY(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.user_id) AS member_ids"
|
||||
)
|
||||
|
||||
|
||||
class UnknownMember(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def decoded(value) -> str:
|
||||
return bytes(value).decode("utf-8")
|
||||
|
||||
|
||||
def public_user(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": decoded(row["display_name"]),
|
||||
"created_at": fmt(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def _chat(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"title": decoded(row["title"]),
|
||||
"member_ids": [str(value) for value in row["member_ids"]],
|
||||
"created_at": fmt(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def _message(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"chat_id": str(row["chat_id"]),
|
||||
"sender_id": str(row["sender_id"]),
|
||||
"text": decoded(row["text"]),
|
||||
"created_at": fmt(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
async def create_user(conn, username: str, display_name: str, password_hash: str) -> Optional[dict]:
|
||||
try:
|
||||
cur = await conn.execute(
|
||||
"INSERT INTO users (id, username, display_name, password_hash, created_at)"
|
||||
" VALUES (gen_random_uuid(), %s, %s, %s, clock_timestamp())"
|
||||
" RETURNING id, username, display_name, created_at",
|
||||
(username, display_name.encode("utf-8"), password_hash),
|
||||
)
|
||||
except psycopg.errors.UniqueViolation:
|
||||
return None
|
||||
return public_user(await cur.fetchone())
|
||||
|
||||
|
||||
async def credentials(conn, username: str):
|
||||
cur = await conn.execute(
|
||||
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
|
||||
(username,),
|
||||
)
|
||||
return await cur.fetchone()
|
||||
|
||||
|
||||
async def create_chat(conn, title: str, member_ids: List[str]) -> dict:
|
||||
cur = await conn.execute(
|
||||
"INSERT INTO chats (id, title, created_at)"
|
||||
" VALUES (gen_random_uuid(), %s, clock_timestamp())"
|
||||
" RETURNING id, title, created_at",
|
||||
(title.encode("utf-8"),),
|
||||
)
|
||||
chat = await cur.fetchone()
|
||||
cur = await conn.execute(
|
||||
"INSERT INTO chat_members (chat_id, user_id) SELECT %s, u.id FROM users u WHERE u.id = ANY(%s::uuid[])",
|
||||
(chat["id"], member_ids),
|
||||
)
|
||||
if cur.rowcount != len(member_ids):
|
||||
raise UnknownMember()
|
||||
chat["member_ids"] = list(member_ids)
|
||||
return _chat(chat)
|
||||
|
||||
|
||||
async def chat_for_member(conn, chat_id: str, user_id: str) -> Optional[dict]:
|
||||
cur = await conn.execute(
|
||||
CHAT_QUERY + " FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s WHERE c.id = %s",
|
||||
(user_id, chat_id),
|
||||
)
|
||||
row = await cur.fetchone()
|
||||
return _chat(row) if row else None
|
||||
|
||||
|
||||
async def list_chats(conn, user_id: str, limit: int, after) -> Tuple[List[dict], bool]:
|
||||
ts, last_id = after if after else (None, None)
|
||||
cur = await conn.execute(
|
||||
CHAT_QUERY
|
||||
+ " FROM chats c JOIN chat_members m ON m.chat_id = c.id"
|
||||
" WHERE m.user_id = %s AND (%s::timestamptz IS NULL OR (c.created_at, c.id) > (%s::timestamptz, %s::uuid))"
|
||||
" ORDER BY c.created_at, c.id LIMIT %s",
|
||||
(user_id, ts, ts, last_id, limit + 1),
|
||||
)
|
||||
rows = await cur.fetchall()
|
||||
return [_chat(row) for row in rows[:limit]], len(rows) > limit
|
||||
|
||||
|
||||
async def create_message(conn, chat_id: str, sender_id: str, text: str) -> Optional[dict]:
|
||||
cur = await conn.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text, created_at)"
|
||||
" SELECT gen_random_uuid(), %s, %s, %s, clock_timestamp()"
|
||||
" WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s)"
|
||||
" RETURNING " + MESSAGE_COLUMNS,
|
||||
(chat_id, sender_id, text.encode("utf-8"), chat_id, sender_id),
|
||||
)
|
||||
row = await cur.fetchone()
|
||||
return _message(row) if row else None
|
||||
|
||||
|
||||
async def list_messages(conn, chat_id: str, limit: int, after) -> Tuple[List[dict], bool]:
|
||||
ts, last_id = after if after else (None, None)
|
||||
cur = await conn.execute(
|
||||
"SELECT " + MESSAGE_COLUMNS + " FROM messages"
|
||||
" WHERE chat_id = %s AND (%s::timestamptz IS NULL OR (created_at, id) > (%s::timestamptz, %s::uuid))"
|
||||
" ORDER BY created_at, id LIMIT %s",
|
||||
(chat_id, ts, ts, last_id, limit + 1),
|
||||
)
|
||||
rows = await cur.fetchall()
|
||||
return [_message(row) for row in rows[:limit]], len(rows) > limit
|
||||
+139
@@ -0,0 +1,139 @@
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import secrets
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Optional
|
||||
|
||||
import valkey.asyncio as valkey
|
||||
|
||||
from app import config
|
||||
from app.cursor import fmt
|
||||
from app.errors import unavailable
|
||||
|
||||
log = logging.getLogger("messenger.sessions")
|
||||
|
||||
|
||||
class SessionStore:
|
||||
def __init__(self, db) -> None:
|
||||
self.db = db
|
||||
self.client = None
|
||||
self.stats = {"hits": 0, "misses": 0, "errors": 0}
|
||||
|
||||
async def open(self) -> None:
|
||||
if not config.CACHE_URL:
|
||||
log.info("session cache disabled: CACHE_URL is empty")
|
||||
return
|
||||
self.client = valkey.Valkey.from_url(
|
||||
config.CACHE_URL,
|
||||
socket_timeout=config.CACHE_TIMEOUT,
|
||||
socket_connect_timeout=config.CACHE_TIMEOUT,
|
||||
decode_responses=True,
|
||||
)
|
||||
|
||||
async def close(self) -> None:
|
||||
if self.client is not None:
|
||||
await self.client.aclose()
|
||||
self.client = None
|
||||
|
||||
@staticmethod
|
||||
def digest(token: str) -> bytes:
|
||||
return hashlib.sha256(token.encode("utf-8")).digest()
|
||||
|
||||
@staticmethod
|
||||
def key(digest: bytes) -> str:
|
||||
return "session:" + digest.hex()
|
||||
|
||||
async def create(self, user: dict) -> tuple:
|
||||
token = secrets.token_urlsafe(32)
|
||||
digest = self.digest(token)
|
||||
expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
|
||||
async with self.db.connection() as conn:
|
||||
await conn.execute(
|
||||
"INSERT INTO sessions (token_hash, user_id, created_at, expires_at)"
|
||||
" VALUES (%s, %s, clock_timestamp(), %s)",
|
||||
(digest, user["id"], expires_at),
|
||||
)
|
||||
await self._cache_put(digest, user, expires_at)
|
||||
return token, fmt(expires_at)
|
||||
|
||||
async def resolve(self, token: str) -> Optional[dict]:
|
||||
digest = self.digest(token)
|
||||
cached = await self._cache_get(digest)
|
||||
if cached is not None:
|
||||
self.stats["hits"] += 1
|
||||
return cached
|
||||
self.stats["misses"] += 1
|
||||
async with self.db.connection() as conn:
|
||||
cur = await conn.execute(
|
||||
"SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at"
|
||||
" FROM sessions s JOIN users u ON u.id = s.user_id"
|
||||
" WHERE s.token_hash = %s AND s.expires_at > now()",
|
||||
(digest,),
|
||||
)
|
||||
row = await cur.fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
user = {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": fmt(row["created_at"]),
|
||||
}
|
||||
await self._cache_put(digest, user, row["expires_at"])
|
||||
return user
|
||||
|
||||
async def revoke(self, token: str) -> None:
|
||||
digest = self.digest(token)
|
||||
await self._cache_drop(digest)
|
||||
async with self.db.connection() as conn:
|
||||
await conn.execute("DELETE FROM sessions WHERE token_hash = %s", (digest,))
|
||||
|
||||
async def sweep(self) -> int:
|
||||
async with self.db.connection() as conn:
|
||||
cur = await conn.execute("DELETE FROM sessions WHERE expires_at <= now()")
|
||||
return cur.rowcount
|
||||
|
||||
def _cache_ttl(self, expires_at: datetime) -> int:
|
||||
remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds())
|
||||
return min(config.SESSION_CACHE_TTL_SECONDS, remaining)
|
||||
|
||||
async def _cache_get(self, digest: bytes) -> Optional[dict]:
|
||||
if self.client is None:
|
||||
return None
|
||||
try:
|
||||
raw = await self.client.get(self.key(digest))
|
||||
except Exception:
|
||||
self._cache_failed("get")
|
||||
return None
|
||||
if not raw:
|
||||
return None
|
||||
try:
|
||||
return json.loads(raw)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
async def _cache_put(self, digest: bytes, user: dict, expires_at: datetime) -> None:
|
||||
if self.client is None:
|
||||
return
|
||||
ttl = self._cache_ttl(expires_at)
|
||||
if ttl <= 0:
|
||||
return
|
||||
try:
|
||||
await self.client.set(self.key(digest), json.dumps(user), ex=ttl)
|
||||
except Exception:
|
||||
self._cache_failed("set")
|
||||
|
||||
async def _cache_drop(self, digest: bytes) -> None:
|
||||
if self.client is None:
|
||||
return
|
||||
try:
|
||||
await self.client.delete(self.key(digest))
|
||||
except Exception:
|
||||
self._cache_failed("delete")
|
||||
raise unavailable("Кэш сессий недоступен, выход из сессии не подтверждён") from None
|
||||
|
||||
def _cache_failed(self, operation: str) -> None:
|
||||
self.stats["errors"] += 1
|
||||
if self.stats["errors"] % 50 == 1:
|
||||
log.warning("session cache %s failed, falling back to postgres (errors=%d)", operation, self.stats["errors"])
|
||||
+101
@@ -0,0 +1,101 @@
|
||||
name: mtusi-lab2
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
POSTGRES_INITDB_ARGS: --data-checksums
|
||||
command:
|
||||
- postgres
|
||||
- -c
|
||||
- synchronous_commit=on
|
||||
- -c
|
||||
- shared_buffers=128MB
|
||||
- -c
|
||||
- work_mem=8MB
|
||||
- -c
|
||||
- max_connections=50
|
||||
- -c
|
||||
- track_io_timing=on
|
||||
secrets:
|
||||
- postgres_password
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
start_period: 10s
|
||||
restart: unless-stopped
|
||||
|
||||
valkey:
|
||||
image: valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507
|
||||
command:
|
||||
- valkey-server
|
||||
- --save
|
||||
- ""
|
||||
- --appendonly
|
||||
- "no"
|
||||
- --maxmemory
|
||||
- 128mb
|
||||
- --maxmemory-policy
|
||||
- allkeys-lru
|
||||
healthcheck:
|
||||
test: ["CMD", "valkey-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
start_period: 5s
|
||||
restart: unless-stopped
|
||||
|
||||
migrate:
|
||||
build:
|
||||
context: .
|
||||
image: mtusi-messenger:lab2
|
||||
command: ["python", "scripts/migrate.py"]
|
||||
environment:
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
secrets:
|
||||
- database_url
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
image: mtusi-messenger:lab2
|
||||
env_file:
|
||||
- .env
|
||||
environment:
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
CACHE_URL_FILE: /run/secrets/cache_url
|
||||
secrets:
|
||||
- database_url
|
||||
- cache_url
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
valkey:
|
||||
condition: service_healthy
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
cache_url:
|
||||
file: ./secrets/cache_url
|
||||
@@ -0,0 +1,29 @@
|
||||
=== 1. Останавливаю кэш сессий (valkey) ===
|
||||
Container mtusi-lab2-valkey-1 Stopping
|
||||
Container mtusi-lab2-valkey-1 Stopped
|
||||
api Up 31 seconds (healthy)
|
||||
postgres Up 37 seconds (unhealthy)
|
||||
PASS login_and_read_work_without_cache
|
||||
PASS unknown_token_is_still_rejected
|
||||
PASS readiness_ignores_the_cache
|
||||
3/3 checks passed
|
||||
Container mtusi-lab2-valkey-1 Starting
|
||||
Container mtusi-lab2-valkey-1 Started
|
||||
|
||||
=== 2. Останавливаю PostgreSQL ===
|
||||
Container mtusi-lab2-postgres-1 Stopping
|
||||
Container mtusi-lab2-postgres-1 Stopped
|
||||
api Up 31 seconds (healthy)
|
||||
valkey Up Less than a second (health: starting)
|
||||
PASS readiness_reports_the_outage
|
||||
PASS writes_fail_with_503
|
||||
PASS unknown_token_never_becomes_trusted
|
||||
PASS login_fails_closed
|
||||
4/4 checks passed
|
||||
Container mtusi-lab2-postgres-1 Starting
|
||||
Container mtusi-lab2-postgres-1 Started
|
||||
|
||||
=== 3. Состояние восстановлено ===
|
||||
api Up 38 seconds (healthy)
|
||||
postgres Up Less than a second (health: starting)
|
||||
valkey Up 7 seconds (healthy)
|
||||
@@ -0,0 +1,5 @@
|
||||
Поднимаю отдельный API с SESSION_TTL_SECONDS=2 на порту 8081 (сеть mtusi-lab2_default)
|
||||
PASS session_expires_after_ttl
|
||||
PASS expired_session_cannot_write_or_logout
|
||||
PASS expires_at_matches_configured_ttl
|
||||
3/3 checks passed
|
||||
@@ -0,0 +1,88 @@
|
||||
sh student-tests/explain.sh
|
||||
=== Стенд ===
|
||||
api mtusi-messenger:lab2 Up About a minute (healthy)
|
||||
postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up About a minute (healthy)
|
||||
valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up Less than a second (health: starting)
|
||||
|
||||
=== Засев 10000 сообщений с неравномерными чатами ===
|
||||
seed_duration | seeded_rows | target_total | messages_total
|
||||
-----------------+-------------+--------------+----------------
|
||||
00:00:00.001309 | 0 | 10000 | 53764
|
||||
(1 row)
|
||||
|
||||
|
||||
=== План запроса истории ===
|
||||
postgres_version
|
||||
-----------------------------------------------------------------------------------------------
|
||||
PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit
|
||||
(1 row)
|
||||
|
||||
messages_total | chats_with_messages | table_size | indexes_size
|
||||
----------------+---------------------+------------+--------------
|
||||
53764 | 14 | 5368 kB | 6320 kB
|
||||
(1 row)
|
||||
|
||||
--- распределение истории по чатам: 5 самых больших и 5 самых маленьких ---
|
||||
chat_id | rows
|
||||
--------------------------------------+-------
|
||||
e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32 | 32944
|
||||
c995246c-35ed-422d-b097-c71f8829a0e0 | 20775
|
||||
d73dc509-7b93-4fc3-b6de-b7079bcc294f | 25
|
||||
7485e75e-455e-4a7b-b164-3dbc84099fc0 | 5
|
||||
63d536a7-78d4-4502-92fa-9bbac4e7c5c4 | 3
|
||||
(5 rows)
|
||||
|
||||
chat_id | rows
|
||||
--------------------------------------+------
|
||||
143b0ced-4c1a-4742-a4ad-02c4b606ba0f | 1
|
||||
b4faa937-91fc-4f41-b25e-f3f692878c1f | 1
|
||||
84d473db-544b-4a24-995b-43a4852c68ab | 1
|
||||
574fc146-1610-484a-85a9-cb084afa7d28 | 1
|
||||
836ed5bf-8ccb-419e-96d5-2c4fe7342292 | 1
|
||||
(5 rows)
|
||||
|
||||
--- A. keyset, первая страница самого большого чата ---
|
||||
QUERY PLAN
|
||||
----------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.41..6.89 rows=50 width=67) (actual time=0.006..0.016 rows=50 loops=1)
|
||||
Buffers: shared hit=24
|
||||
-> Index Scan using messages_history_idx on messages (cost=0.41..4269.16 rows=32968 width=67) (actual time=0.006..0.014 rows=50 loops=1)
|
||||
Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid)
|
||||
Buffers: shared hit=24
|
||||
Planning:
|
||||
Buffers: shared hit=6
|
||||
Planning Time: 0.046 ms
|
||||
Execution Time: 0.026 ms
|
||||
(9 rows)
|
||||
|
||||
--- B. keyset, страница на глубине 90% истории (так работает cursor API) ---
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.41..11.51 rows=50 width=67) (actual time=0.017..0.025 rows=50 loops=1)
|
||||
Buffers: shared hit=53
|
||||
-> Index Scan using messages_history_idx on messages (cost=0.41..3272.65 rows=14746 width=67) (actual time=0.017..0.023 rows=50 loops=1)
|
||||
Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid)))
|
||||
Buffers: shared hit=53
|
||||
Planning Time: 0.027 ms
|
||||
Execution Time: 0.063 ms
|
||||
(7 rows)
|
||||
|
||||
--- C. OFFSET на той же глубине (так API не делает: цена растёт со страницей) ---
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=3839.41..3845.89 rows=50 width=67) (actual time=4.152..4.159 rows=50 loops=1)
|
||||
Buffers: shared hit=29813
|
||||
-> Index Scan using messages_history_idx on messages (cost=0.41..4269.16 rows=32968 width=67) (actual time=0.008..3.474 rows=29699 loops=1)
|
||||
Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid)
|
||||
Buffers: shared hit=29813
|
||||
Planning Time: 0.018 ms
|
||||
Execution Time: 4.172 ms
|
||||
(7 rows)
|
||||
|
||||
--- индексы таблицы messages ---
|
||||
index | size | scans
|
||||
----------------------+---------+-------
|
||||
messages_history_idx | 4072 kB | 12
|
||||
messages_pkey | 2248 kB | 0
|
||||
(2 rows)
|
||||
|
||||
@@ -0,0 +1,32 @@
|
||||
M .env.example
|
||||
M Makefile
|
||||
M REPORT.md
|
||||
?? .github/workflows/app.yml
|
||||
?? Dockerfile
|
||||
?? app/
|
||||
?? compose.yaml
|
||||
?? evidence/dependency.txt
|
||||
?? evidence/expiry.txt
|
||||
?? evidence/explain-10k.txt
|
||||
?? evidence/git-hygiene.txt
|
||||
?? evidence/level4-tests.txt
|
||||
?? evidence/load-cache.json
|
||||
?? evidence/load-nocache.json
|
||||
?? evidence/load.txt
|
||||
?? evidence/migrations.txt
|
||||
?? evidence/outages.txt
|
||||
?? evidence/persistence.txt
|
||||
?? evidence/smoke.txt
|
||||
?? evidence/stand.txt
|
||||
?? evidence/track2/
|
||||
?? migrations/
|
||||
?? requirements.txt
|
||||
?? scripts/bootstrap.sh
|
||||
?? scripts/migrate.py
|
||||
?? scripts/restart.sh
|
||||
?? student-tests/
|
||||
--- правила игнорирования ---
|
||||
.gitignore:2:.env .env
|
||||
.gitignore:5:secrets/ secrets/database_url
|
||||
.gitignore:5:secrets/ secrets/postgres_password
|
||||
.gitignore:15:backups/ backups
|
||||
@@ -0,0 +1,24 @@
|
||||
PASS wrong_password_gives_same_401
|
||||
PASS basic_is_rejected_on_business_endpoints
|
||||
PASS x_user_id_does_not_authenticate
|
||||
PASS logout_revokes_only_its_own_token
|
||||
PASS token_is_opaque_and_unique
|
||||
PASS short_password_is_rejected
|
||||
PASS password_is_never_returned
|
||||
PASS login_rejects_a_request_body
|
||||
PASS broken_utf8_credentials_are_rejected
|
||||
9/9 checks passed
|
||||
|
||||
PASS duplicate_username_race_creates_one_user
|
||||
PASS unknown_member_rolls_chat_back
|
||||
PASS keyset_pagination_is_complete
|
||||
PASS cursor_is_bound_to_its_chat
|
||||
PASS limit_bounds_are_enforced
|
||||
PASS sql_injection_is_not_executed
|
||||
PASS malformed_requests_are_rejected
|
||||
PASS nul_and_unicode_text_round_trips
|
||||
PASS text_length_limit_counts_code_points
|
||||
PASS unicode_blanks_are_rejected
|
||||
PASS broken_json_does_not_break_the_api
|
||||
PASS content_type_is_required
|
||||
12/12 checks passed
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 2,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 30.0,
|
||||
"elapsed_seconds": 30.012,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 32944,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 1097.706,
|
||||
"successful_latency_ms": {
|
||||
"p50": 3.248,
|
||||
"p95": 6.063,
|
||||
"p99": 10.603
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 2,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 30.0,
|
||||
"elapsed_seconds": 30.033,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 20775,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 691.741,
|
||||
"successful_latency_ms": {
|
||||
"p50": 5.447,
|
||||
"p95": 8.152,
|
||||
"p99": 11.778
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
{
|
||||
"lab": 2,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 30.0,
|
||||
"elapsed_seconds": 30.012,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 32944,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 1097.706,
|
||||
"successful_latency_ms": {
|
||||
"p50": 3.248,
|
||||
"p95": 6.063,
|
||||
"p99": 10.603
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
{
|
||||
"lab": 2,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 30.0,
|
||||
"elapsed_seconds": 30.033,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 20775,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 691.741,
|
||||
"successful_latency_ms": {
|
||||
"p50": 5.447,
|
||||
"p95": 8.152,
|
||||
"p99": 11.778
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
--- первый запуск (из логов сервиса migrate) ---
|
||||
migrate-1 | apply 0001_init
|
||||
migrate-1 | migrations complete: 1 file(s)
|
||||
--- повторный запуск ---
|
||||
Container mtusi-lab2-postgres-1 Running
|
||||
Container mtusi-lab2-postgres-1 Waiting
|
||||
Container mtusi-lab2-postgres-1 Healthy
|
||||
Container mtusi-lab2-migrate-run-d04acc691283 Creating
|
||||
Container mtusi-lab2-migrate-run-d04acc691283 Created
|
||||
skip 0001_init
|
||||
migrations complete: 1 file(s)
|
||||
--- схема ---
|
||||
Table "public.messages"
|
||||
Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description
|
||||
------------+--------------------------+-----------+----------+---------+----------+-------------+--------------+-------------
|
||||
id | uuid | | not null | | plain | | |
|
||||
chat_id | uuid | | not null | | plain | | |
|
||||
sender_id | uuid | | not null | | plain | | |
|
||||
text | bytea | | not null | | extended | | |
|
||||
created_at | timestamp with time zone | | not null | | plain | | |
|
||||
Indexes:
|
||||
"messages_pkey" PRIMARY KEY, btree (id)
|
||||
"messages_history_idx" btree (chat_id, created_at, id)
|
||||
Check constraints:
|
||||
"messages_text_size" CHECK (octet_length(text) >= 1 AND octet_length(text) <= 16000)
|
||||
Foreign-key constraints:
|
||||
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
|
||||
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE RESTRICT
|
||||
Access method: heap
|
||||
|
||||
version | checksum | applied_at
|
||||
-----------+------------------------------------------------------------------+-------------------------------
|
||||
0001_init | 4fd0a8c68a5cffd3ae67a21646eb1928477d18b8716e68c1220469d858ccb9c1 | 2026-10-19 15:50:30.673311+00
|
||||
(1 row)
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
PASS revoked_session_stays_revoked_after_cache_restart
|
||||
PASS logout_is_not_confirmed_while_cache_is_down
|
||||
PASS cached_sessions_do_not_cross_users
|
||||
PASS hung_database_fails_fast
|
||||
4/4 checks passed
|
||||
@@ -0,0 +1,18 @@
|
||||
--- состояние контейнеров до рестарта ---
|
||||
api Up 38 seconds (healthy)
|
||||
postgres Up Less than a second (health: starting)
|
||||
valkey Up 7 seconds (healthy)
|
||||
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost: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.
|
||||
--- состояние контейнеров после рестарта ---
|
||||
api Up Less than a second (health: starting)
|
||||
postgres Up Less than a second (health: starting)
|
||||
valkey Up Less than a second (health: starting)
|
||||
--- логи postgres о перезапуске ---
|
||||
postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: starting PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit
|
||||
postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432
|
||||
postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: listening on IPv6 address "::", port 5432
|
||||
postgres-1 | 2026-10-19 15:51:09.946 UTC [1] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
|
||||
postgres-1 | 2026-10-19 15:51:09.949 UTC [29] LOG: database system was shut down at 2026-10-19 15:51:09 UTC
|
||||
postgres-1 | 2026-10-19 15:51:09.951 UTC [1] LOG: database system is ready to accept connections
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,8 @@
|
||||
Darwin arm64
|
||||
Docker version 29.7.2, build a7dcaa6
|
||||
Docker Compose version v5.5.1
|
||||
api mtusi-messenger:lab2 Up 1 second (health: starting)
|
||||
postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up 7 seconds (healthy)
|
||||
valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up 7 seconds (healthy)
|
||||
PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit
|
||||
Valkey server v=8.1.10 sha=00000000:1 malloc=jemalloc-5.3.0 bits=64 build=2cb63ac0e4567989
|
||||
@@ -0,0 +1,227 @@
|
||||
=== Стенд и версии ===
|
||||
api mtusi-messenger:lab2 Up About a minute (healthy)
|
||||
postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up About a minute (healthy)
|
||||
valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up Less than a second (health: starting)
|
||||
Darwin arm64
|
||||
Docker version 29.7.2, build a7dcaa6
|
||||
|
||||
=== 1. Засев истории: цель 120000 сообщений, чаты неравномерные ===
|
||||
seed_duration | seeded_rows | target_total | messages_total
|
||||
----------------+-------------+--------------+----------------
|
||||
00:00:00.63315 | 66236 | 120000 | 120000
|
||||
(1 row)
|
||||
|
||||
|
||||
=== 2. Сравнение индексов и цены записи (каждый вариант в откатываемой транзакции) ===
|
||||
messages_total
|
||||
----------------
|
||||
120000
|
||||
(1 row)
|
||||
|
||||
############ Вариант A: messages_history_idx (chat_id, created_at, id) ############
|
||||
index_size
|
||||
------------
|
||||
10 MB
|
||||
(1 row)
|
||||
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.42..37.36 rows=50 width=89) (actual time=0.015..0.025 rows=50 loops=1)
|
||||
Buffers: shared hit=53
|
||||
-> Index Scan using messages_history_idx on messages (cost=0.42..5594.06 rows=7570 width=89) (actual time=0.014..0.022 rows=50 loops=1)
|
||||
Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid)))
|
||||
Buffers: shared hit=53
|
||||
Planning:
|
||||
Buffers: shared hit=17
|
||||
Planning Time: 0.098 ms
|
||||
Execution Time: 0.048 ms
|
||||
(9 rows)
|
||||
|
||||
pages_measured
|
||||
----------------
|
||||
5000
|
||||
(1 row)
|
||||
|
||||
hundred_pages_duration
|
||||
------------------------
|
||||
00:00:00.001121
|
||||
(1 row)
|
||||
|
||||
insert_10k_duration
|
||||
---------------------
|
||||
00:00:00.083689
|
||||
(1 row)
|
||||
|
||||
############ Вариант B: только (chat_id) ############
|
||||
index_size
|
||||
------------
|
||||
848 kB
|
||||
(1 row)
|
||||
|
||||
QUERY PLAN
|
||||
------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=3134.85..3134.97 rows=50 width=89) (actual time=1.691..1.695 rows=50 loops=1)
|
||||
Buffers: shared hit=411 read=30
|
||||
I/O Timings: shared read=0.076
|
||||
-> Sort (cost=3134.85..3153.65 rows=7522 width=89) (actual time=1.691..1.692 rows=50 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 33kB
|
||||
Buffers: shared hit=411 read=30
|
||||
I/O Timings: shared read=0.076
|
||||
-> Bitmap Heap Scan on messages (cost=368.71..2884.97 rows=7522 width=89) (actual time=1.378..1.560 rows=3294 loops=1)
|
||||
Recheck Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid)
|
||||
Filter: (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid))
|
||||
Rows Removed by Filter: 29650
|
||||
Heap Blocks: exact=411
|
||||
Buffers: shared hit=411 read=30
|
||||
I/O Timings: shared read=0.076
|
||||
-> Bitmap Index Scan on messages_chat_only_idx (cost=0.00..366.83 rows=32872 width=0) (actual time=0.333..0.333 rows=32944 loops=1)
|
||||
Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid)
|
||||
Buffers: shared read=30
|
||||
I/O Timings: shared read=0.076
|
||||
Planning:
|
||||
Buffers: shared hit=26 read=1
|
||||
I/O Timings: shared read=0.009
|
||||
Planning Time: 0.130 ms
|
||||
Execution Time: 1.728 ms
|
||||
(24 rows)
|
||||
|
||||
pages_measured
|
||||
----------------
|
||||
5000
|
||||
(1 row)
|
||||
|
||||
hundred_pages_duration
|
||||
------------------------
|
||||
00:00:02.186353
|
||||
(1 row)
|
||||
|
||||
insert_10k_duration
|
||||
---------------------
|
||||
00:00:00.078473
|
||||
(1 row)
|
||||
|
||||
############ Вариант C: (chat_id, created_at, id) INCLUDE (sender_id, text) ############
|
||||
index_size
|
||||
------------
|
||||
14 MB
|
||||
(1 row)
|
||||
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.42..34.19 rows=50 width=89) (actual time=0.017..0.021 rows=50 loops=1)
|
||||
Buffers: shared hit=1 read=3
|
||||
I/O Timings: shared read=0.006
|
||||
-> Index Only Scan using messages_history_covering_idx on messages (cost=0.42..5110.68 rows=7565 width=89) (actual time=0.016..0.019 rows=50 loops=1)
|
||||
Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid)))
|
||||
Heap Fetches: 0
|
||||
Buffers: shared hit=1 read=3
|
||||
I/O Timings: shared read=0.006
|
||||
Planning:
|
||||
Buffers: shared hit=28 read=1
|
||||
I/O Timings: shared read=0.005
|
||||
Planning Time: 0.184 ms
|
||||
Execution Time: 0.031 ms
|
||||
(13 rows)
|
||||
|
||||
pages_measured
|
||||
----------------
|
||||
5000
|
||||
(1 row)
|
||||
|
||||
hundred_pages_duration
|
||||
------------------------
|
||||
00:00:00.000744
|
||||
(1 row)
|
||||
|
||||
insert_10k_duration
|
||||
---------------------
|
||||
00:00:00.084611
|
||||
(1 row)
|
||||
|
||||
############ Схема после эксперимента (ROLLBACK вернул индексы) ############
|
||||
indexname
|
||||
----------------------
|
||||
messages_history_idx
|
||||
messages_pkey
|
||||
(2 rows)
|
||||
|
||||
|
||||
Самый большой чат: e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32
|
||||
|
||||
=== 3. Состояние источника до бэкапа ===
|
||||
relation | rows
|
||||
--------------+--------
|
||||
chat_members | 1036
|
||||
chats | 68
|
||||
messages | 120000
|
||||
sessions | 43
|
||||
users | 74
|
||||
(5 rows)
|
||||
|
||||
big_chat_rows | big_chat_md5
|
||||
---------------+----------------------------------
|
||||
32944 | 6c6725a76404fbb0b8b5b509707e30b5
|
||||
(1 row)
|
||||
|
||||
id | created_at | text
|
||||
--------------------------------------+-------------------------------+----------
|
||||
8ecedfe9-56ef-410d-98b3-e3fc414128d9 | 2026-10-19 15:51:11.010631+00 | load-1-0
|
||||
424bfa46-6e49-4b60-8ca3-ac3c3f9be02a | 2026-10-19 15:51:11.011234+00 | load-3-0
|
||||
05b0e1a2-5862-461a-b8aa-1f91f647e18d | 2026-10-19 15:51:11.01201+00 | load-2-0
|
||||
(3 rows)
|
||||
|
||||
marker_rows
|
||||
-------------
|
||||
0
|
||||
(1 row)
|
||||
|
||||
|
||||
=== 4. Бэкап pg_dump -Fc ===
|
||||
backup_seconds=0.761
|
||||
dump_size=5.6M
|
||||
|
||||
=== 5. Запись после бэкапа: граница потери данных ===
|
||||
в источнике маркеров: 1
|
||||
|
||||
=== 6. Новое хранилище: отдельный контейнер и отдельный том ===
|
||||
/var/run/postgresql:5432 - accepting connections
|
||||
|
||||
=== 7. Восстановление в новое хранилище ===
|
||||
restore_seconds=0.370
|
||||
|
||||
=== 8. Сверка восстановленной копии ===
|
||||
relation | rows
|
||||
--------------+--------
|
||||
chat_members | 1036
|
||||
chats | 68
|
||||
messages | 120000
|
||||
sessions | 43
|
||||
users | 74
|
||||
(5 rows)
|
||||
|
||||
big_chat_rows | big_chat_md5
|
||||
---------------+----------------------------------
|
||||
32944 | 6c6725a76404fbb0b8b5b509707e30b5
|
||||
(1 row)
|
||||
|
||||
id | created_at | text
|
||||
--------------------------------------+-------------------------------+----------
|
||||
8ecedfe9-56ef-410d-98b3-e3fc414128d9 | 2026-10-19 15:51:11.010631+00 | load-1-0
|
||||
424bfa46-6e49-4b60-8ca3-ac3c3f9be02a | 2026-10-19 15:51:11.011234+00 | load-3-0
|
||||
05b0e1a2-5862-461a-b8aa-1f91f647e18d | 2026-10-19 15:51:11.01201+00 | load-2-0
|
||||
(3 rows)
|
||||
|
||||
marker_rows
|
||||
-------------
|
||||
0
|
||||
(1 row)
|
||||
|
||||
|
||||
=== 9. Итог ===
|
||||
backup_seconds=0.761 restore_seconds=0.370
|
||||
messages_source_without_marker=120000 messages_restored=120000
|
||||
big_chat_md5_source=6c6725a76404fbb0b8b5b509707e30b5
|
||||
big_chat_md5_restored=6c6725a76404fbb0b8b5b509707e30b5
|
||||
RESULT: восстановленная копия совпадает с источником на момент бэкапа
|
||||
маркеров после бэкапа в восстановленной копии: 0 (ожидается 0: всё, что подтверждено после снимка, в дампе отсутствует)
|
||||
@@ -0,0 +1,46 @@
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL UNIQUE
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name bytea NOT NULL
|
||||
CONSTRAINT users_display_name_size CHECK (octet_length(display_name) BETWEEN 1 AND 400),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title bytea NOT NULL
|
||||
CONSTRAINT chats_title_size CHECK (octet_length(title) BETWEEN 1 AND 400),
|
||||
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) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT,
|
||||
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) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT,
|
||||
text bytea NOT NULL
|
||||
CONSTRAINT messages_text_size CHECK (octet_length(text) BETWEEN 1 AND 16000),
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
|
||||
created_at timestamptz NOT NULL,
|
||||
expires_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
|
||||
@@ -0,0 +1,22 @@
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
argon2-cffi==25.1.0
|
||||
argon2-cffi-bindings==26.1.0
|
||||
cffi==2.1.1
|
||||
click==8.5.0
|
||||
fastapi==0.115.6
|
||||
h11==0.16.0
|
||||
httptools==0.9.0
|
||||
idna==3.20
|
||||
psycopg==3.3.6
|
||||
psycopg-binary==3.3.6
|
||||
psycopg-pool==3.3.3
|
||||
pycparser==3.11
|
||||
pydantic==2.14.1
|
||||
pydantic-core==2.50.1
|
||||
starlette==0.41.3
|
||||
typing-extensions==4.16.0
|
||||
typing-inspection==0.4.4
|
||||
uvicorn==0.34.0
|
||||
uvloop==0.23.0
|
||||
valkey==6.2.0
|
||||
Executable
+15
@@ -0,0 +1,15 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
[ -f .env ] || cp .env.example .env
|
||||
mkdir -p secrets
|
||||
if [ ! -f secrets/postgres_password ]; then
|
||||
python3 -c "import secrets; print(secrets.token_urlsafe(24))" > secrets/postgres_password
|
||||
fi
|
||||
password=$(cat secrets/postgres_password)
|
||||
printf 'postgresql://messenger:%s@postgres:5432/messenger\n' "$password" > secrets/database_url
|
||||
printf 'valkey://valkey:6379/0\n' > secrets/cache_url
|
||||
chmod 700 secrets
|
||||
chmod 600 secrets/postgres_password secrets/database_url secrets/cache_url
|
||||
echo "ready: .env and secrets/ created locally; they stay out of Git"
|
||||
@@ -0,0 +1,60 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Versioned SQL migrations: applied once, checksum-verified, safe to re-run."""
|
||||
import hashlib
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
import psycopg
|
||||
|
||||
ROOT = pathlib.Path(__file__).resolve().parents[1]
|
||||
MIGRATIONS = ROOT / "migrations"
|
||||
LOCK_ID = 2026_0002
|
||||
|
||||
|
||||
def database_url() -> str:
|
||||
path = os.environ.get("DATABASE_URL_FILE")
|
||||
if path:
|
||||
return pathlib.Path(path).read_text(encoding="utf-8").strip()
|
||||
url = os.environ.get("DATABASE_URL", "").strip()
|
||||
if not url:
|
||||
sys.exit("DATABASE_URL or DATABASE_URL_FILE is required")
|
||||
return url
|
||||
|
||||
|
||||
def main() -> None:
|
||||
files = sorted(MIGRATIONS.glob("*.sql"))
|
||||
if not files:
|
||||
sys.exit("no migration files found in %s" % MIGRATIONS)
|
||||
with psycopg.connect(database_url(), autocommit=True, connect_timeout=10) as conn:
|
||||
conn.execute(
|
||||
"CREATE TABLE IF NOT EXISTS schema_migrations ("
|
||||
" version text PRIMARY KEY,"
|
||||
" checksum text NOT NULL,"
|
||||
" applied_at timestamptz NOT NULL DEFAULT now())"
|
||||
)
|
||||
conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
|
||||
rows = conn.execute("SELECT version, checksum FROM schema_migrations").fetchall()
|
||||
applied = {row[0]: row[1] for row in rows}
|
||||
for path in files:
|
||||
version = path.stem
|
||||
body = path.read_text(encoding="utf-8")
|
||||
checksum = hashlib.sha256(body.encode("utf-8")).hexdigest()
|
||||
if version in applied:
|
||||
if applied[version] != checksum:
|
||||
sys.exit("migration %s changed after it was applied" % version)
|
||||
print("skip %s" % version)
|
||||
continue
|
||||
with conn.transaction():
|
||||
conn.execute(body)
|
||||
conn.execute(
|
||||
"INSERT INTO schema_migrations (version, checksum) VALUES (%s, %s)",
|
||||
(version, checksum),
|
||||
)
|
||||
print("apply %s" % version)
|
||||
conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,))
|
||||
print("migrations complete: %d file(s)" % len(files))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+5
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
docker compose --env-file .env restart postgres valkey api
|
||||
@@ -0,0 +1,111 @@
|
||||
"""Shared HTTP helpers for the student checks; stdlib only, Python 3.9+."""
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
DEFAULT_BASE = os.environ.get("BASE_URL", "http://localhost:8080")
|
||||
|
||||
|
||||
class Failed(AssertionError):
|
||||
pass
|
||||
|
||||
|
||||
def expect(condition, message):
|
||||
if not condition:
|
||||
raise Failed(message)
|
||||
|
||||
|
||||
def call(base, method, path, body=None, token=None, headers=None, timeout=10, raw=None, content_type=None):
|
||||
sent = {"Accept": "application/json"}
|
||||
data = raw
|
||||
if body is not None:
|
||||
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
||||
sent["Content-Type"] = "application/json"
|
||||
if content_type is not None:
|
||||
sent["Content-Type"] = content_type
|
||||
if token:
|
||||
sent["Authorization"] = "Bearer " + token
|
||||
sent.update(headers or {})
|
||||
request = urllib.request.Request(base + path, data=data, headers=sent, method=method)
|
||||
try:
|
||||
response = urllib.request.urlopen(request, timeout=timeout)
|
||||
except urllib.error.HTTPError as error:
|
||||
response = error
|
||||
except (urllib.error.URLError, TimeoutError, OSError) as exc:
|
||||
raise Failed("%s %s: нет соединения (%s)" % (method, path, type(exc).__name__)) from None
|
||||
with response:
|
||||
raw = response.read()
|
||||
payload = None
|
||||
if raw:
|
||||
try:
|
||||
payload = json.loads(raw)
|
||||
except ValueError:
|
||||
payload = None
|
||||
return {"status": response.code, "headers": response.headers, "json": payload}
|
||||
|
||||
|
||||
def credentials(label="check"):
|
||||
return {
|
||||
"username": "u_%s_%s" % (label, uuid.uuid4().hex[:10]),
|
||||
"display_name": "Проверка " + label,
|
||||
"password": "T3st-" + uuid.uuid4().hex,
|
||||
}
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
return "Basic " + base64.b64encode(("%s:%s" % (username, password)).encode("utf-8")).decode()
|
||||
|
||||
|
||||
def register(base, label="check"):
|
||||
body = credentials(label)
|
||||
result = call(base, "POST", "/api/v1/users", body=body)
|
||||
expect(result["status"] == 201, "регистрация вернула %s" % result["status"])
|
||||
return {"registration": body, "user": result["json"], "id": result["json"]["id"]}
|
||||
|
||||
|
||||
def login(base, actor):
|
||||
result = call(
|
||||
base,
|
||||
"POST",
|
||||
"/api/v1/auth/sessions",
|
||||
headers={"Authorization": basic(actor["registration"]["username"], actor["registration"]["password"])},
|
||||
)
|
||||
expect(result["status"] == 201, "вход вернул %s" % result["status"])
|
||||
actor["token"] = result["json"]["token"]
|
||||
actor["session"] = result["json"]
|
||||
return actor
|
||||
|
||||
|
||||
def member(base, label="check"):
|
||||
return login(base, register(base, label))
|
||||
|
||||
|
||||
def chat_with(base, owner, *others):
|
||||
members = [owner["id"]] + [other["id"] for other in others]
|
||||
result = call(base, "POST", "/api/v1/chats", body={"title": "Проверка " + uuid.uuid4().hex[:8], "member_ids": members}, token=owner["token"])
|
||||
expect(result["status"] == 201, "создание чата вернуло %s" % result["status"])
|
||||
return result["json"]
|
||||
|
||||
|
||||
def arguments(description):
|
||||
parser = argparse.ArgumentParser(description=description)
|
||||
parser.add_argument("--base-url", default=DEFAULT_BASE)
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def run(tests, base):
|
||||
failures = []
|
||||
for test in tests:
|
||||
try:
|
||||
test(base)
|
||||
print("PASS %s" % test.__name__)
|
||||
except AssertionError as exc:
|
||||
failures.append(test.__name__)
|
||||
print("FAIL %s: %s" % (test.__name__, exc))
|
||||
print("%d/%d checks passed" % (len(tests) - len(failures), len(tests)))
|
||||
sys.exit(1 if failures else 0)
|
||||
Executable
+39
@@ -0,0 +1,39 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
COMPOSE="docker compose --env-file .env"
|
||||
|
||||
wait_ready() {
|
||||
i=0
|
||||
while [ "$i" -lt 60 ]; do
|
||||
if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then return 0; fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
echo "API не стал ready" >&2
|
||||
return 1
|
||||
}
|
||||
|
||||
restore() {
|
||||
$COMPOSE start valkey postgres >/dev/null 2>&1 || true
|
||||
}
|
||||
trap restore EXIT
|
||||
|
||||
echo "=== 1. Останавливаю кэш сессий (valkey) ==="
|
||||
$COMPOSE stop valkey
|
||||
$COMPOSE ps --format '{{.Service}} {{.Status}}'
|
||||
python3 student-tests/test_without_cache.py --base-url http://localhost:8080
|
||||
$COMPOSE start valkey
|
||||
wait_ready
|
||||
|
||||
echo
|
||||
echo "=== 2. Останавливаю PostgreSQL ==="
|
||||
$COMPOSE stop postgres
|
||||
$COMPOSE ps --format '{{.Service}} {{.Status}}'
|
||||
python3 student-tests/test_without_db.py --base-url http://localhost:8080
|
||||
$COMPOSE start postgres
|
||||
wait_ready
|
||||
echo
|
||||
echo "=== 3. Состояние восстановлено ==="
|
||||
$COMPOSE ps --format '{{.Service}} {{.Status}}'
|
||||
Executable
+126
@@ -0,0 +1,126 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
OUT=${OUT:-evidence}
|
||||
TOTAL=${TOTAL:-120000}
|
||||
COMPOSE="docker compose --env-file .env"
|
||||
|
||||
mkdir -p "$OUT" "$OUT/track2"
|
||||
|
||||
step() {
|
||||
printf '\n######## %s ########\n' "$1"
|
||||
}
|
||||
|
||||
wait_ready() {
|
||||
i=0
|
||||
while [ "$i" -lt 90 ]; do
|
||||
if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then return 0; fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
echo "API не стал ready" >&2
|
||||
return 1
|
||||
}
|
||||
|
||||
step "0. Чистый стенд: удаляю том базы и поднимаю заново"
|
||||
$COMPOSE down -v
|
||||
$COMPOSE up -d --build
|
||||
wait_ready
|
||||
{
|
||||
uname -sm
|
||||
docker --version
|
||||
$COMPOSE version
|
||||
$COMPOSE ps --format '{{.Service}} {{.Image}} {{.Status}}'
|
||||
$COMPOSE exec -T postgres psql -U messenger -d messenger -t -A -c 'select version()'
|
||||
$COMPOSE exec -T valkey valkey-server --version
|
||||
} > "$OUT/stand.txt" 2>&1
|
||||
cat "$OUT/stand.txt"
|
||||
|
||||
step "1. Миграции с нуля и повторный запуск"
|
||||
{
|
||||
echo '--- первый запуск (из логов сервиса migrate) ---'
|
||||
$COMPOSE logs migrate --tail=10
|
||||
echo '--- повторный запуск ---'
|
||||
$COMPOSE run --rm migrate
|
||||
echo '--- схема ---'
|
||||
$COMPOSE exec -T postgres psql -U messenger -d messenger -X -c '\d+ messages'
|
||||
$COMPOSE exec -T postgres psql -U messenger -d messenger -X -c 'table schema_migrations'
|
||||
} > "$OUT/migrations.txt" 2>&1
|
||||
tail -5 "$OUT/migrations.txt"
|
||||
|
||||
step "2. Публичный smoke"
|
||||
make test > "$OUT/smoke.txt" 2>&1
|
||||
tail -1 "$OUT/smoke.txt"
|
||||
|
||||
step "3. Свои проверки уровня 4"
|
||||
{
|
||||
python3 student-tests/test_auth_sessions.py
|
||||
echo
|
||||
python3 student-tests/test_storage_rules.py
|
||||
} > "$OUT/level4-tests.txt" 2>&1
|
||||
grep 'checks passed' "$OUT/level4-tests.txt"
|
||||
|
||||
step "4. Истечение сессии при коротком TTL"
|
||||
sh student-tests/expiry.sh > "$OUT/expiry.txt" 2>&1
|
||||
grep 'checks passed' "$OUT/expiry.txt"
|
||||
|
||||
step "5. Отзыв сессии против кэша и зависшая БД"
|
||||
python3 student-tests/test_outages.py > "$OUT/outages.txt" 2>&1
|
||||
grep 'checks passed' "$OUT/outages.txt"
|
||||
|
||||
step "6. Отказ Valkey, затем отказ PostgreSQL"
|
||||
sh student-tests/dependency.sh > "$OUT/dependency.txt" 2>&1
|
||||
grep 'checks passed' "$OUT/dependency.txt"
|
||||
|
||||
step "7. Рестарт API и всех хранилищ"
|
||||
{
|
||||
echo '--- состояние контейнеров до рестарта ---'
|
||||
$COMPOSE ps --format '{{.Service}} {{.Status}}'
|
||||
} > "$OUT/persistence.txt" 2>&1
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh >> "$OUT/persistence.txt" 2>&1
|
||||
{
|
||||
echo '--- состояние контейнеров после рестарта ---'
|
||||
$COMPOSE ps --format '{{.Service}} {{.Status}}'
|
||||
echo '--- логи postgres о перезапуске ---'
|
||||
$COMPOSE logs postgres --tail=6
|
||||
} >> "$OUT/persistence.txt" 2>&1
|
||||
grep 'PASS\|FAIL' "$OUT/persistence.txt"
|
||||
|
||||
step "8. Нагрузка с кэшем сессий и без него"
|
||||
python3 tests/load.py --duration 30 --concurrency 4 --output "$OUT/load-cache.json" > "$OUT/load.txt" 2>&1
|
||||
$COMPOSE stop valkey
|
||||
python3 tests/load.py --duration 30 --concurrency 4 --output "$OUT/load-nocache.json" >> "$OUT/load.txt" 2>&1
|
||||
$COMPOSE start valkey
|
||||
wait_ready
|
||||
python3 - "$OUT" <<'PYEOF'
|
||||
import json
|
||||
import sys
|
||||
|
||||
out = sys.argv[1]
|
||||
for name in ("load-cache", "load-nocache"):
|
||||
with open(out + "/" + name + ".json") as handle:
|
||||
data = json.load(handle)
|
||||
print(name, data["successful_requests"], "ok,", data["failed_requests"], "fail,",
|
||||
data["successful_rps"], "rps,", data["successful_latency_ms"])
|
||||
PYEOF
|
||||
|
||||
step "9. План запроса истории"
|
||||
make explain > "$OUT/explain-10k.txt" 2>&1
|
||||
grep -E 'messages_total|Execution Time' "$OUT/explain-10k.txt" | head -8
|
||||
|
||||
step "10. Трек 5: индексы и восстановление"
|
||||
TOTAL="$TOTAL" sh student-tests/track2.sh > "$OUT/track2/run.txt" 2>&1
|
||||
grep -E 'backup_seconds|restore_seconds|RESULT|маркеров' "$OUT/track2/run.txt"
|
||||
|
||||
step "11. Гигиена репозитория"
|
||||
{
|
||||
git status --porcelain
|
||||
echo '--- правила игнорирования ---'
|
||||
git check-ignore -v .env secrets/database_url secrets/postgres_password backups || true
|
||||
} > "$OUT/git-hygiene.txt" 2>&1
|
||||
cat "$OUT/git-hygiene.txt"
|
||||
|
||||
step "Готово"
|
||||
echo "Файлы доказательств: $OUT"
|
||||
ls -1 "$OUT" "$OUT/track2"
|
||||
Executable
+35
@@ -0,0 +1,35 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
NAME=mtusi-lab2-api-shortttl
|
||||
PORT=${PORT:-8081}
|
||||
NETWORK=$(docker compose --env-file .env ps --format '{{.Name}}' api | head -1 | xargs -I{} docker inspect {} --format '{{range $k,$v := .NetworkSettings.Networks}}{{$k}}{{end}}')
|
||||
|
||||
cleanup() {
|
||||
docker rm -f "$NAME" >/dev/null 2>&1 || true
|
||||
}
|
||||
trap cleanup EXIT
|
||||
cleanup
|
||||
|
||||
echo "Поднимаю отдельный API с SESSION_TTL_SECONDS=2 на порту $PORT (сеть $NETWORK)"
|
||||
docker run -d --name "$NAME" --network "$NETWORK" \
|
||||
-p 127.0.0.1:"$PORT":8080 \
|
||||
-v "$PWD/secrets/database_url:/run/secrets/database_url:ro" \
|
||||
-v "$PWD/secrets/cache_url:/run/secrets/cache_url:ro" \
|
||||
-e DATABASE_URL_FILE=/run/secrets/database_url \
|
||||
-e CACHE_URL_FILE=/run/secrets/cache_url \
|
||||
-e SESSION_TTL_SECONDS=2 \
|
||||
-e SESSION_CACHE_TTL_SECONDS=2 \
|
||||
-e SESSION_SWEEP_SECONDS=5 \
|
||||
mtusi-messenger:lab2 >/dev/null
|
||||
|
||||
i=0
|
||||
while [ "$i" -lt 60 ]; do
|
||||
if curl -fsS "http://localhost:$PORT/health/ready" >/dev/null 2>&1; then break; fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
curl -fsS "http://localhost:$PORT/health/ready" >/dev/null
|
||||
|
||||
python3 student-tests/test_expiry.py --base-url "http://localhost:$PORT"
|
||||
Executable
+15
@@ -0,0 +1,15 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
TOTAL=${TOTAL:-10000}
|
||||
PSQL="docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -X -q"
|
||||
|
||||
echo "=== Стенд ==="
|
||||
docker compose --env-file .env ps --format '{{.Service}} {{.Image}} {{.Status}}'
|
||||
echo
|
||||
echo "=== Засев $TOTAL сообщений с неравномерными чатами ==="
|
||||
$PSQL -v total="$TOTAL" -f - < student-tests/seed.sql
|
||||
echo
|
||||
echo "=== План запроса истории ==="
|
||||
$PSQL -f - < student-tests/explain.sql
|
||||
@@ -0,0 +1,51 @@
|
||||
\set ON_ERROR_STOP on
|
||||
|
||||
SELECT version() AS postgres_version;
|
||||
|
||||
SELECT count(*) AS messages_total,
|
||||
count(DISTINCT chat_id) AS chats_with_messages,
|
||||
pg_size_pretty(pg_table_size('messages')) AS table_size,
|
||||
pg_size_pretty(pg_indexes_size('messages')) AS indexes_size
|
||||
FROM messages;
|
||||
|
||||
\echo '--- распределение истории по чатам: 5 самых больших и 5 самых маленьких ---'
|
||||
SELECT chat_id, count(*) AS rows FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 5;
|
||||
SELECT chat_id, count(*) AS rows FROM messages GROUP BY chat_id ORDER BY count(*) ASC LIMIT 5;
|
||||
|
||||
SELECT chat_id AS big_chat, count(*) AS big_rows
|
||||
FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1 \gset
|
||||
|
||||
SELECT created_at AS cur_ts, id AS cur_id
|
||||
FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
ORDER BY created_at, id
|
||||
OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 1 \gset
|
||||
|
||||
\echo '--- A. keyset, первая страница самого большого чата ---'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
ORDER BY created_at, id
|
||||
LIMIT 50;
|
||||
|
||||
\echo '--- B. keyset, страница на глубине 90% истории (так работает cursor API) ---'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
|
||||
ORDER BY created_at, id
|
||||
LIMIT 50;
|
||||
|
||||
\echo '--- C. OFFSET на той же глубине (так API не делает: цена растёт со страницей) ---'
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
ORDER BY created_at, id
|
||||
OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 50;
|
||||
|
||||
\echo '--- индексы таблицы messages ---'
|
||||
SELECT indexrelname AS index, pg_size_pretty(pg_relation_size(indexrelid)) AS size, idx_scan AS scans
|
||||
FROM pg_stat_user_indexes WHERE relname = 'messages' ORDER BY indexrelname;
|
||||
@@ -0,0 +1,37 @@
|
||||
\set ON_ERROR_STOP on
|
||||
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
SELECT gen_random_uuid(), 'load_' || g, convert_to('Нагрузка ' || g, 'UTF8'), 'seed-row-cannot-log-in', now()
|
||||
FROM generate_series(1, 20) AS g
|
||||
ON CONFLICT (username) DO NOTHING;
|
||||
|
||||
INSERT INTO chats (id, title, created_at)
|
||||
SELECT gen_random_uuid(), convert_to('load chat ' || g, 'UTF8'), now()
|
||||
FROM generate_series(1, 50) AS g
|
||||
WHERE NOT EXISTS (SELECT 1 FROM chats WHERE title = convert_to('load chat ' || g, 'UTF8'));
|
||||
|
||||
INSERT INTO chat_members (chat_id, user_id)
|
||||
SELECT c.id, u.id
|
||||
FROM chats c CROSS JOIN users u
|
||||
WHERE position(convert_to('load chat ', 'UTF8') in c.title) = 1 AND u.username LIKE 'load\_%'
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
SELECT greatest(0, :total - (SELECT count(*) FROM messages)) AS to_seed \gset
|
||||
SELECT clock_timestamp() AS seed_started \gset
|
||||
|
||||
WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1),
|
||||
u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%')
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(),
|
||||
c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int],
|
||||
u.ids[1 + floor(array_length(u.ids, 1) * random())::int],
|
||||
convert_to('load message ' || g || ' ' || md5(g::text), 'UTF8'),
|
||||
now() - make_interval(secs => (:to_seed - g) / 100.0)
|
||||
FROM generate_series(1, :to_seed) AS g, c, u;
|
||||
|
||||
SELECT clock_timestamp() - :'seed_started'::timestamptz AS seed_duration,
|
||||
:to_seed AS seeded_rows,
|
||||
:total AS target_total,
|
||||
(SELECT count(*) FROM messages) AS messages_total;
|
||||
|
||||
ANALYZE users, chats, chat_members, messages;
|
||||
@@ -0,0 +1,114 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Level 4: session semantics — wrong password, challenges, logout, token quality."""
|
||||
import json
|
||||
import uuid
|
||||
|
||||
from common import arguments, basic, call, credentials, expect, login, member, register, run
|
||||
|
||||
|
||||
def wrong_password_gives_same_401(base):
|
||||
actor = register(base, "pw")
|
||||
name = actor["registration"]["username"]
|
||||
wrong = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": basic(name, "wrong-password-123")})
|
||||
unknown = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": basic("u_absent_" + uuid.uuid4().hex[:8], "wrong-password-123")})
|
||||
expect(wrong["status"] == unknown["status"] == 401, "ожидался 401 в обоих случаях")
|
||||
expect(wrong["json"]["error"]["code"] == unknown["json"]["error"]["code"] == "unauthorized", "код ошибки отличается")
|
||||
expect(wrong["headers"].get("WWW-Authenticate", "").startswith("Basic"), "нет Basic challenge")
|
||||
expect(wrong["json"]["error"]["request_id"] == wrong["headers"].get("X-Request-Id"), "request_id не совпадает с заголовком")
|
||||
|
||||
|
||||
def basic_is_rejected_on_business_endpoints(base):
|
||||
actor = register(base, "basic")
|
||||
name = actor["registration"]["username"]
|
||||
password = actor["registration"]["password"]
|
||||
result = call(base, "GET", "/api/v1/users/me", headers={"Authorization": basic(name, password)})
|
||||
expect(result["status"] == 401, "Basic на /users/me вернул %s" % result["status"])
|
||||
expect(result["headers"].get("WWW-Authenticate", "").startswith("Bearer"), "нет Bearer challenge")
|
||||
|
||||
|
||||
def x_user_id_does_not_authenticate(base):
|
||||
alice = member(base, "alice")
|
||||
bob = register(base, "bob")
|
||||
anonymous = call(base, "GET", "/api/v1/users/me", headers={"X-User-Id": alice["id"]})
|
||||
expect(anonymous["status"] == 401, "X-User-Id без Bearer дал %s" % anonymous["status"])
|
||||
overridden = call(base, "GET", "/api/v1/users/me", token=alice["token"], headers={"X-User-Id": bob["id"]})
|
||||
expect(overridden["status"] == 200 and overridden["json"]["id"] == alice["id"], "X-User-Id подменил владельца сессии")
|
||||
|
||||
|
||||
def logout_revokes_only_its_own_token(base):
|
||||
actor = member(base, "logout")
|
||||
second = login(base, dict(actor))
|
||||
first_token = actor["token"]
|
||||
revoked = call(base, "DELETE", "/api/v1/auth/sessions/current", token=first_token)
|
||||
expect(revoked["status"] == 204, "logout вернул %s" % revoked["status"])
|
||||
expect(call(base, "GET", "/api/v1/users/me", token=first_token)["status"] == 401, "отозванный токен всё ещё работает")
|
||||
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=first_token)["status"] == 401, "повторный logout не 401")
|
||||
expect(call(base, "GET", "/api/v1/users/me", token=second["token"])["status"] == 200, "logout убил вторую сессию")
|
||||
|
||||
|
||||
def token_is_opaque_and_unique(base):
|
||||
actor = member(base, "token")
|
||||
name = actor["registration"]["username"]
|
||||
expect(len(actor["token"]) >= 32, "токен короче 32 символов")
|
||||
expect(name not in actor["token"] and actor["id"] not in actor["token"], "токен раскрывает имя или id пользователя")
|
||||
again = login(base, dict(actor))
|
||||
expect(again["token"] != actor["token"], "повторный вход выдал тот же токен")
|
||||
expect(actor["session"]["token_type"] == "Bearer", "token_type не Bearer")
|
||||
|
||||
|
||||
def short_password_is_rejected(base):
|
||||
body = credentials("short")
|
||||
body["password"] = "short"
|
||||
expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "короткий пароль принят")
|
||||
body = credentials("long")
|
||||
body["password"] = "x" * 129
|
||||
expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "пароль длиннее 128 принят")
|
||||
|
||||
|
||||
def password_is_never_returned(base):
|
||||
actor = member(base, "leak")
|
||||
expect("password" not in actor["user"] and "password_hash" not in actor["user"], "User содержит пароль")
|
||||
me = call(base, "GET", "/api/v1/users/me", token=actor["token"])["json"]
|
||||
expect(set(me) == {"id", "username", "display_name", "created_at"}, "в /users/me лишние поля: %s" % sorted(me))
|
||||
expect("password" not in str(actor["session"]["user"]), "сессия раскрывает пароль")
|
||||
|
||||
|
||||
def login_rejects_a_request_body(base):
|
||||
actor = register(base, "body")
|
||||
header = basic(actor["registration"]["username"], actor["registration"]["password"])
|
||||
with_body = call(base, "POST", "/api/v1/auth/sessions", body={"username": actor["registration"]["username"]}, headers={"Authorization": header})
|
||||
expect(with_body["status"] == 400, "вход с JSON-телом дал %s" % with_body["status"])
|
||||
raw_body = call(base, "POST", "/api/v1/auth/sessions", raw=b"anything", headers={"Authorization": header}, content_type="text/plain")
|
||||
expect(raw_body["status"] == 400, "вход с произвольным телом дал %s" % raw_body["status"])
|
||||
clean = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header})
|
||||
expect(clean["status"] == 201, "вход без тела дал %s" % clean["status"])
|
||||
|
||||
|
||||
def broken_utf8_credentials_are_rejected(base):
|
||||
actor = register(base, "utf8")
|
||||
name = actor["registration"]["username"]
|
||||
import base64 as b64
|
||||
|
||||
header = "Basic " + b64.b64encode(name.encode() + b":" + actor["registration"]["password"].encode() + b"\xff").decode()
|
||||
result = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header})
|
||||
expect(result["status"] == 401, "повреждённый UTF-8 в пароле дал %s" % result["status"])
|
||||
body = credentials("utf8reg")
|
||||
bad_body = json.dumps(body, ensure_ascii=False).encode("utf-8").replace(b'"password"', b'"passw\xffrd"')
|
||||
broken = call(base, "POST", "/api/v1/users", raw=bad_body, content_type="application/json")
|
||||
expect(broken["status"] == 400, "повреждённый UTF-8 в теле дал %s" % broken["status"])
|
||||
|
||||
|
||||
TESTS = [
|
||||
wrong_password_gives_same_401,
|
||||
basic_is_rejected_on_business_endpoints,
|
||||
x_user_id_does_not_authenticate,
|
||||
logout_revokes_only_its_own_token,
|
||||
token_is_opaque_and_unique,
|
||||
short_password_is_rejected,
|
||||
password_is_never_returned,
|
||||
login_rejects_a_request_body,
|
||||
broken_utf8_credentials_are_rejected,
|
||||
]
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(TESTS, arguments(__doc__).base_url)
|
||||
@@ -0,0 +1,44 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Level 4: session expiry on a short SESSION_TTL_SECONDS instance."""
|
||||
import time
|
||||
|
||||
from common import arguments, call, expect, member, run
|
||||
|
||||
TTL = 2
|
||||
|
||||
|
||||
def session_expires_after_ttl(base):
|
||||
actor = member(base, "ttl")
|
||||
alive = call(base, "GET", "/api/v1/users/me", token=actor["token"])
|
||||
expect(alive["status"] == 200, "свежая сессия дала %s" % alive["status"])
|
||||
time.sleep(TTL + 2)
|
||||
expired = call(base, "GET", "/api/v1/users/me", token=actor["token"])
|
||||
expect(expired["status"] == 401, "истёкшая сессия дала %s" % expired["status"])
|
||||
expect(expired["headers"].get("WWW-Authenticate", "").startswith("Bearer"), "нет Bearer challenge")
|
||||
expect(expired["json"]["error"]["code"] == "unauthorized", "код ошибки %s" % expired["json"]["error"]["code"])
|
||||
|
||||
|
||||
def expired_session_cannot_write_or_logout(base):
|
||||
alice = member(base, "ttlwrite")
|
||||
bob = member(base, "ttlwrite2")
|
||||
chat = call(base, "POST", "/api/v1/chats", body={"title": "Срок жизни", "member_ids": [alice["id"], bob["id"]]}, token=alice["token"])
|
||||
expect(chat["status"] == 201, "создание чата дало %s" % chat["status"])
|
||||
time.sleep(TTL + 2)
|
||||
write = call(base, "POST", "/api/v1/chats/%s/messages" % chat["json"]["id"], body={"text": "после истечения"}, token=alice["token"])
|
||||
expect(write["status"] == 401, "запись истёкшим токеном дала %s" % write["status"])
|
||||
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=alice["token"])["status"] == 401, "logout истёкшим токеном не 401")
|
||||
|
||||
|
||||
def expires_at_matches_configured_ttl(base):
|
||||
import datetime as dt
|
||||
|
||||
actor = member(base, "ttlvalue")
|
||||
expires_at = dt.datetime.fromisoformat(actor["session"]["expires_at"][:-1] + "+00:00")
|
||||
remaining = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
|
||||
expect(0 < remaining <= TTL + 1, "expires_at обещает %.1f c при TTL=%d" % (remaining, TTL))
|
||||
|
||||
|
||||
TESTS = [session_expires_after_ttl, expired_session_cannot_write_or_logout, expires_at_matches_configured_ttl]
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(TESTS, arguments(__doc__).base_url)
|
||||
@@ -0,0 +1,93 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Level 4/5: revocation must outlive the cache and outages must never grant trust."""
|
||||
import pathlib
|
||||
import subprocess
|
||||
import time
|
||||
|
||||
from common import arguments, call, chat_with, expect, member, run
|
||||
|
||||
ROOT = pathlib.Path(__file__).resolve().parents[1]
|
||||
COMPOSE = ["docker", "compose", "--env-file", ".env"]
|
||||
|
||||
|
||||
def compose(*args):
|
||||
subprocess.run(COMPOSE + list(args), cwd=str(ROOT), check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
|
||||
|
||||
def wait_ready(base, seconds=90):
|
||||
deadline = time.monotonic() + seconds
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
if call(base, "GET", "/health/ready")["status"] == 200:
|
||||
return
|
||||
except AssertionError:
|
||||
pass
|
||||
time.sleep(0.5)
|
||||
raise AssertionError("API не стал ready за %d с" % seconds)
|
||||
|
||||
|
||||
def revoked_session_stays_revoked_after_cache_restart(base):
|
||||
actor = member(base, "revoke")
|
||||
expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 200, "свежая сессия не работает")
|
||||
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"])["status"] == 204, "logout не вернул 204")
|
||||
compose("restart", "valkey")
|
||||
wait_ready(base)
|
||||
after = call(base, "GET", "/api/v1/users/me", token=actor["token"])
|
||||
expect(after["status"] == 401, "отозванная сессия вернула доступ после рестарта кэша: %s" % after["status"])
|
||||
|
||||
|
||||
def logout_is_not_confirmed_while_cache_is_down(base):
|
||||
actor = member(base, "logoutdown")
|
||||
expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 200, "свежая сессия не работает")
|
||||
compose("stop", "valkey")
|
||||
try:
|
||||
refused = call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"])
|
||||
expect(refused["status"] == 503, "logout без кэша дал %s вместо 503" % refused["status"])
|
||||
still = call(base, "GET", "/api/v1/users/me", token=actor["token"])
|
||||
expect(still["status"] == 200, "сессия не отозвана, но доступ уже потерян: %s" % still["status"])
|
||||
finally:
|
||||
compose("start", "valkey")
|
||||
wait_ready(base)
|
||||
expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"])["status"] == 204, "повторный logout не прошёл")
|
||||
expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 401, "после подтверждённого logout токен жив")
|
||||
|
||||
|
||||
def cached_sessions_do_not_cross_users(base):
|
||||
alice = member(base, "cross")
|
||||
bob = member(base, "cross2")
|
||||
for _ in range(3):
|
||||
first = call(base, "GET", "/api/v1/users/me", token=alice["token"])["json"]
|
||||
second = call(base, "GET", "/api/v1/users/me", token=bob["token"])["json"]
|
||||
expect(first["id"] == alice["id"] and second["id"] == bob["id"], "кэш перепутал владельцев сессий")
|
||||
chat = chat_with(base, alice, bob)
|
||||
sent = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "от боба"}, token=bob["token"])
|
||||
expect(sent["json"]["sender_id"] == bob["id"], "sender_id взят не из сессии")
|
||||
|
||||
|
||||
def hung_database_fails_fast(base):
|
||||
actor = member(base, "hang")
|
||||
compose("pause", "postgres")
|
||||
try:
|
||||
started = time.monotonic()
|
||||
result = call(base, "GET", "/api/v1/chats", token=actor["token"], timeout=60)
|
||||
elapsed = time.monotonic() - started
|
||||
expect(result["status"] == 503, "зависшая БД дала %s вместо 503" % result["status"])
|
||||
expect(elapsed < 10, "ответ пришёл за %.1f с при заявленном клиентском лимите 6 с" % elapsed)
|
||||
ready = call(base, "GET", "/health/ready", timeout=60)
|
||||
expect(ready["status"] == 503, "/health/ready при зависшей БД дал %s" % ready["status"])
|
||||
expect(call(base, "GET", "/health/live", timeout=60)["status"] == 200, "/health/live упал вместе с БД")
|
||||
finally:
|
||||
compose("unpause", "postgres")
|
||||
wait_ready(base)
|
||||
expect(call(base, "GET", "/api/v1/chats", token=actor["token"])["status"] == 200, "после возврата БД доступ не восстановился")
|
||||
|
||||
|
||||
TESTS = [
|
||||
revoked_session_stays_revoked_after_cache_restart,
|
||||
logout_is_not_confirmed_while_cache_is_down,
|
||||
cached_sessions_do_not_cross_users,
|
||||
hung_database_fails_fast,
|
||||
]
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(TESTS, arguments(__doc__).base_url)
|
||||
@@ -0,0 +1,242 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Level 4: PostgreSQL rules — username race, transaction rollback, keyset paging, injection."""
|
||||
import threading
|
||||
import uuid
|
||||
from urllib.parse import quote
|
||||
|
||||
from common import arguments, call, chat_with, credentials, expect, member, run
|
||||
|
||||
RACE_CLIENTS = 12
|
||||
|
||||
|
||||
def duplicate_username_race_creates_one_user(base):
|
||||
body = credentials("race")
|
||||
results = []
|
||||
lock = threading.Lock()
|
||||
ready = threading.Barrier(RACE_CLIENTS)
|
||||
|
||||
def attempt():
|
||||
ready.wait()
|
||||
result = call(base, "POST", "/api/v1/users", body=body)
|
||||
with lock:
|
||||
results.append(result["status"])
|
||||
|
||||
threads = [threading.Thread(target=attempt) for _ in range(RACE_CLIENTS)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
created = results.count(201)
|
||||
conflicts = results.count(409)
|
||||
expect(created == 1, "создано %d пользователей с одним username (ожидался 1): %s" % (created, results))
|
||||
expect(created + conflicts == RACE_CLIENTS, "неожиданные ответы в гонке: %s" % results)
|
||||
|
||||
|
||||
def unknown_member_rolls_chat_back(base):
|
||||
alice = member(base, "rollback")
|
||||
title = "Откат " + uuid.uuid4().hex[:8]
|
||||
body = {"title": title, "member_ids": [alice["id"], str(uuid.uuid4())]}
|
||||
result = call(base, "POST", "/api/v1/chats", body=body, token=alice["token"])
|
||||
expect(result["status"] == 400, "неизвестный участник дал %s" % result["status"])
|
||||
listed = call(base, "GET", "/api/v1/chats?limit=100", token=alice["token"])["json"]
|
||||
expect(all(chat["title"] != title for chat in listed["items"]), "чат остался в базе после отката")
|
||||
|
||||
|
||||
def keyset_pagination_is_complete(base):
|
||||
alice = member(base, "pages")
|
||||
bob = member(base, "pages2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
total = 25
|
||||
for index in range(total):
|
||||
result = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "сообщение %d" % index}, token=alice["token"])
|
||||
expect(result["status"] == 201, "отправка %d вернула %s" % (index, result["status"]))
|
||||
seen = []
|
||||
cursor = None
|
||||
for _ in range(total):
|
||||
path = "/api/v1/chats/%s/messages?limit=7" % chat["id"]
|
||||
if cursor:
|
||||
path += "&cursor=" + quote(cursor, safe="")
|
||||
page = call(base, "GET", path, token=bob["token"])["json"]
|
||||
seen.extend(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
expect(cursor is None, "обход истории не завершился")
|
||||
ids = [item["id"] for item in seen]
|
||||
expect(len(ids) == total, "прочитано %d сообщений из %d" % (len(ids), total))
|
||||
expect(len(set(ids)) == total, "в обходе есть повторы")
|
||||
keys = [(item["created_at"], uuid.UUID(item["id"]).int) for item in seen]
|
||||
expect(keys == sorted(keys), "порядок (created_at, id) нарушен")
|
||||
|
||||
|
||||
def cursor_is_bound_to_its_chat(base):
|
||||
alice = member(base, "cursor")
|
||||
bob = member(base, "cursor2")
|
||||
first = chat_with(base, alice, bob)
|
||||
second = chat_with(base, alice, bob)
|
||||
for chat in (first, second):
|
||||
for index in range(3):
|
||||
call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "текст %d" % index}, token=alice["token"])
|
||||
page = call(base, "GET", "/api/v1/chats/%s/messages?limit=1" % first["id"], token=alice["token"])["json"]
|
||||
expect(page["next_cursor"], "нет курсора для проверки")
|
||||
foreign = call(base, "GET", "/api/v1/chats/%s/messages?limit=1&cursor=%s" % (second["id"], quote(page["next_cursor"], safe="")), token=alice["token"])
|
||||
expect(foreign["status"] == 400, "курсор другого чата принят: %s" % foreign["status"])
|
||||
tampered = page["next_cursor"][:-2] + ("aa" if not page["next_cursor"].endswith("aa") else "bb")
|
||||
altered = call(base, "GET", "/api/v1/chats/%s/messages?cursor=%s" % (first["id"], quote(tampered, safe="")), token=alice["token"])
|
||||
expect(altered["status"] == 400, "изменённый курсор принят: %s" % altered["status"])
|
||||
|
||||
|
||||
def limit_bounds_are_enforced(base):
|
||||
alice = member(base, "limit")
|
||||
bob = member(base, "limit2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
for value in ("0", "101", "abc", "-1", "1.5", ""):
|
||||
result = call(base, "GET", "/api/v1/chats/%s/messages?limit=%s" % (chat["id"], quote(value, safe="")), token=alice["token"])
|
||||
expect(result["status"] == 400, "limit=%r дал %s" % (value, result["status"]))
|
||||
valid = call(base, "GET", "/api/v1/chats/%s/messages?limit=100" % chat["id"], token=alice["token"])
|
||||
expect(valid["status"] == 200, "limit=100 дал %s" % valid["status"])
|
||||
|
||||
|
||||
def sql_injection_is_not_executed(base):
|
||||
probes = ["ad'; DROP TABLE users; --", "' OR '1'='1", "admin\"--", "ad\\'; SELECT 1"]
|
||||
for probe in probes:
|
||||
body = credentials("inj")
|
||||
body["username"] = probe
|
||||
result = call(base, "POST", "/api/v1/users", body=body)
|
||||
expect(result["status"] == 400, "username %r дал %s" % (probe, result["status"]))
|
||||
alice = member(base, "after")
|
||||
bob = member(base, "after2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
text = "текст с кавычкой ' и ; DROP TABLE messages; --"
|
||||
created = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": text}, token=alice["token"])
|
||||
expect(created["status"] == 201 and created["json"]["text"] == text, "текст с кавычками испорчен или отклонён")
|
||||
history = call(base, "GET", "/api/v1/chats/%s/messages" % chat["id"], token=bob["token"])["json"]
|
||||
expect(any(item["text"] == text for item in history["items"]), "сообщение не читается после вставки")
|
||||
|
||||
|
||||
def malformed_requests_are_rejected(base):
|
||||
alice = member(base, "shape")
|
||||
bob = member(base, "shape2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
path = "/api/v1/chats/%s/messages" % chat["id"]
|
||||
expect(call(base, "POST", path, body={"text": "ок", "sender_id": alice["id"]}, token=alice["token"])["status"] == 400, "лишнее поле принято")
|
||||
expect(call(base, "POST", path, body={}, token=alice["token"])["status"] == 400, "пустой объект принят")
|
||||
expect(call(base, "POST", path, body={"text": " "}, token=alice["token"])["status"] == 400, "пробельный текст принят")
|
||||
expect(call(base, "POST", path, body={"text": "x" * 4001}, token=alice["token"])["status"] == 400, "текст длиннее 4000 принят")
|
||||
expect(call(base, "GET", "/api/v1/chats/not-a-uuid", token=alice["token"])["status"] == 400, "неверный UUID дал не 400")
|
||||
expect(call(base, "GET", "/api/v1/chats/%s" % uuid.uuid4(), token=alice["token"])["status"] == 404, "чужой чат дал не 404")
|
||||
|
||||
|
||||
def nul_and_unicode_text_round_trips(base):
|
||||
alice = member(base, "unicode")
|
||||
bob = member(base, "unicode2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
path = "/api/v1/chats/%s/messages" % chat["id"]
|
||||
samples = [
|
||||
"a\u0000b",
|
||||
"\u0000",
|
||||
"emoji \U0001f44b и ZWJ \U0001f469\u200d\U0001f4bb",
|
||||
"комбинация e\u0301 и RTL \u05d0\u05d1",
|
||||
"край \u0007\u001b\u007f",
|
||||
]
|
||||
created = []
|
||||
for sample in samples:
|
||||
result = call(base, "POST", path, body={"text": sample}, token=alice["token"])
|
||||
expect(result["status"] == 201, "текст %r дал %s" % (sample, result["status"]))
|
||||
expect(result["json"]["text"] == sample, "текст изменён при записи: %r -> %r" % (sample, result["json"]["text"]))
|
||||
created.append(result["json"])
|
||||
history = call(base, "GET", path + "?limit=100", token=bob["token"])["json"]["items"]
|
||||
by_id = {item["id"]: item["text"] for item in history}
|
||||
for item in created:
|
||||
expect(by_id.get(item["id"]) == item["text"], "текст изменён при чтении: %r" % item["text"])
|
||||
|
||||
|
||||
def text_length_limit_counts_code_points(base):
|
||||
alice = member(base, "length")
|
||||
bob = member(base, "length2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
path = "/api/v1/chats/%s/messages" % chat["id"]
|
||||
exact = "\U0001f600" * 4000
|
||||
result = call(base, "POST", path, body={"text": exact}, token=alice["token"])
|
||||
expect(result["status"] == 201, "4000 code points дали %s" % result["status"])
|
||||
expect(result["json"]["text"] == exact, "текст на границе изменён")
|
||||
over = call(base, "POST", path, body={"text": "\U0001f600" * 4001}, token=alice["token"])
|
||||
expect(over["status"] == 400, "4001 code point дал %s" % over["status"])
|
||||
|
||||
|
||||
def unicode_blanks_are_rejected(base):
|
||||
alice = member(base, "blank")
|
||||
bob = member(base, "blank2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
path = "/api/v1/chats/%s/messages" % chat["id"]
|
||||
blanks = [" ", "\t\n", "\u00a0", "\u2007", "\u3000", "\u200b", "\u200b \u200b", "\ufeff"]
|
||||
for blank in blanks:
|
||||
result = call(base, "POST", path, body={"text": blank}, token=alice["token"])
|
||||
expect(result["status"] == 400, "пробельный текст %r дал %s" % (blank, result["status"]))
|
||||
for field in ("display_name",):
|
||||
body = credentials("blank")
|
||||
body[field] = "\u200b"
|
||||
expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "пустой %s принят" % field)
|
||||
titles = call(base, "POST", "/api/v1/chats", body={"title": "\u00a0", "member_ids": [alice["id"]]}, token=alice["token"])
|
||||
expect(titles["status"] == 400, "пробельный title принят: %s" % titles["status"])
|
||||
|
||||
|
||||
def broken_json_does_not_break_the_api(base):
|
||||
alice = member(base, "json")
|
||||
bob = member(base, "json2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
path = "/api/v1/chats/%s/messages" % chat["id"]
|
||||
payloads = [
|
||||
b'{"text": 1e999}',
|
||||
b'{"text": NaN}',
|
||||
b'{"text": Infinity}',
|
||||
b'{"text": 1e+}',
|
||||
b'{"text": ' + b"9" * 5000 + b"}",
|
||||
b'{"text": ' + b"[" * 2000 + b"]" * 2000 + b"}",
|
||||
b"[" * 2000,
|
||||
b'{"text": {"text": "nested object"}}',
|
||||
b'{"text": "\xff\xfe"}',
|
||||
b"",
|
||||
b"{",
|
||||
]
|
||||
for payload in payloads:
|
||||
result = call(base, "POST", path, raw=payload, token=alice["token"], content_type="application/json")
|
||||
expect(result["status"] == 400, "тело %r дало %s" % (payload[:24], result["status"]))
|
||||
alive = call(base, "POST", path, body={"text": "после битого JSON"}, token=alice["token"])
|
||||
expect(alive["status"] == 201, "API не отвечает после битых тел: %s" % alive["status"])
|
||||
|
||||
|
||||
def content_type_is_required(base):
|
||||
alice = member(base, "ctype")
|
||||
bob = member(base, "ctype2")
|
||||
chat = chat_with(base, alice, bob)
|
||||
path = "/api/v1/chats/%s/messages" % chat["id"]
|
||||
for content_type in ("text/plain", "application/x-www-form-urlencoded", "", "application/jsonx"):
|
||||
result = call(base, "POST", path, raw=b'{"text":"x"}', token=alice["token"], content_type=content_type)
|
||||
expect(result["status"] == 415, "Content-Type %r дал %s" % (content_type, result["status"]))
|
||||
body = credentials("ctype")
|
||||
import json as jsonlib
|
||||
|
||||
plain = call(base, "POST", "/api/v1/users", raw=jsonlib.dumps(body).encode(), content_type="text/plain")
|
||||
expect(plain["status"] == 415, "регистрация с text/plain дала %s" % plain["status"])
|
||||
charset = call(base, "POST", path, raw=b'{"text":"charset"}', token=alice["token"], content_type="application/json; charset=utf-8")
|
||||
expect(charset["status"] == 201, "application/json с charset дал %s" % charset["status"])
|
||||
|
||||
|
||||
TESTS = [
|
||||
duplicate_username_race_creates_one_user,
|
||||
unknown_member_rolls_chat_back,
|
||||
keyset_pagination_is_complete,
|
||||
cursor_is_bound_to_its_chat,
|
||||
limit_bounds_are_enforced,
|
||||
sql_injection_is_not_executed,
|
||||
malformed_requests_are_rejected,
|
||||
nul_and_unicode_text_round_trips,
|
||||
text_length_limit_counts_code_points,
|
||||
unicode_blanks_are_rejected,
|
||||
broken_json_does_not_break_the_api,
|
||||
content_type_is_required,
|
||||
]
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(TESTS, arguments(__doc__).base_url)
|
||||
@@ -0,0 +1,32 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Level 4: the API keeps working from PostgreSQL while the session cache is down."""
|
||||
from common import arguments, call, chat_with, expect, member, run
|
||||
|
||||
|
||||
def login_and_read_work_without_cache(base):
|
||||
alice = member(base, "nocache")
|
||||
bob = member(base, "nocache2")
|
||||
me = call(base, "GET", "/api/v1/users/me", token=alice["token"])
|
||||
expect(me["status"] == 200 and me["json"]["id"] == alice["id"], "/users/me без кэша дал %s" % me["status"])
|
||||
chat = chat_with(base, alice, bob)
|
||||
sent = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "кэш выключен"}, token=alice["token"])
|
||||
expect(sent["status"] == 201, "запись без кэша дала %s" % sent["status"])
|
||||
history = call(base, "GET", "/api/v1/chats/%s/messages" % chat["id"], token=bob["token"])
|
||||
expect(history["status"] == 200, "чтение без кэша дало %s" % history["status"])
|
||||
expect(any(item["id"] == sent["json"]["id"] for item in history["json"]["items"]), "сообщение не видно без кэша")
|
||||
|
||||
|
||||
def unknown_token_is_still_rejected(base):
|
||||
expect(call(base, "GET", "/api/v1/users/me", token="definitely-not-a-valid-session-token")["status"] == 401, "неизвестный токен принят")
|
||||
expect(call(base, "GET", "/api/v1/users/me")["status"] == 401, "анонимный запрос принят")
|
||||
|
||||
|
||||
def readiness_ignores_the_cache(base):
|
||||
ready = call(base, "GET", "/health/ready")
|
||||
expect(ready["status"] == 200, "/health/ready без кэша дал %s" % ready["status"])
|
||||
|
||||
|
||||
TESTS = [login_and_read_work_without_cache, unknown_token_is_still_rejected, readiness_ignores_the_cache]
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(TESTS, arguments(__doc__).base_url)
|
||||
@@ -0,0 +1,41 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Level 4: with PostgreSQL stopped the API degrades to a bounded error, never to trust."""
|
||||
import uuid
|
||||
|
||||
from common import arguments, call, expect, run
|
||||
|
||||
|
||||
def readiness_reports_the_outage(base):
|
||||
ready = call(base, "GET", "/health/ready")
|
||||
expect(ready["status"] == 503, "/health/ready без БД дал %s" % ready["status"])
|
||||
expect(ready["json"]["error"]["code"] == "unavailable", "код ошибки %s" % ready["json"]["error"]["code"])
|
||||
live = call(base, "GET", "/health/live")
|
||||
expect(live["status"] == 200, "/health/live без БД дал %s" % live["status"])
|
||||
|
||||
|
||||
def writes_fail_with_503(base):
|
||||
body = {"username": "u_nodb_" + uuid.uuid4().hex[:8], "display_name": "Без БД", "password": "T3st-" + uuid.uuid4().hex}
|
||||
created = call(base, "POST", "/api/v1/users", body=body)
|
||||
expect(created["status"] == 503, "регистрация без БД дала %s" % created["status"])
|
||||
|
||||
|
||||
def unknown_token_never_becomes_trusted(base):
|
||||
for token in ("definitely-not-a-valid-session-token", uuid.uuid4().hex):
|
||||
result = call(base, "GET", "/api/v1/users/me", token=token)
|
||||
expect(result["status"] in (401, 503), "неизвестный токен без БД дал %s" % result["status"])
|
||||
anonymous = call(base, "GET", "/api/v1/chats", token=None)
|
||||
expect(anonymous["status"] == 401, "анонимный запрос без БД дал %s" % anonymous["status"])
|
||||
|
||||
|
||||
def login_fails_closed(base):
|
||||
import base64
|
||||
|
||||
header = "Basic " + base64.b64encode(b"u_any_user:any-password-123").decode()
|
||||
result = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header})
|
||||
expect(result["status"] in (401, 503), "вход без БД дал %s" % result["status"])
|
||||
|
||||
|
||||
TESTS = [readiness_reports_the_outage, writes_fail_with_503, unknown_token_never_becomes_trusted, login_fails_closed]
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(TESTS, arguments(__doc__).base_url)
|
||||
Executable
+113
@@ -0,0 +1,113 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
TOTAL=${TOTAL:-120000}
|
||||
IMAGE=postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2
|
||||
RNAME=mtusi-lab2-restore
|
||||
RVOL=mtusi-lab2-restore-data
|
||||
PSQL="docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -X -q"
|
||||
RPSQL="docker exec -i $RNAME psql -U messenger -d messenger_restored -X -q"
|
||||
STAMP=$(date +%Y%m%d-%H%M%S)
|
||||
DUMP="backups/messenger-$STAMP.dump"
|
||||
|
||||
now_ms() {
|
||||
python3 -c 'import time; print(int(time.time() * 1000))'
|
||||
}
|
||||
|
||||
elapsed() {
|
||||
python3 -c "print('%.3f' % ((int('$2') - int('$1')) / 1000.0))"
|
||||
}
|
||||
|
||||
cleanup() {
|
||||
if [ "${KEEP:-0}" != "1" ]; then
|
||||
docker rm -f "$RNAME" >/dev/null 2>&1 || true
|
||||
docker volume rm "$RVOL" >/dev/null 2>&1 || true
|
||||
fi
|
||||
}
|
||||
trap cleanup EXIT
|
||||
|
||||
mkdir -p backups
|
||||
|
||||
echo "=== Стенд и версии ==="
|
||||
docker compose --env-file .env ps --format '{{.Service}} {{.Image}} {{.Status}}'
|
||||
uname -sm
|
||||
docker --version
|
||||
|
||||
echo
|
||||
echo "=== 1. Засев истории: цель $TOTAL сообщений, чаты неравномерные ==="
|
||||
$PSQL -v total="$TOTAL" -f - < student-tests/seed.sql
|
||||
|
||||
echo
|
||||
echo "=== 2. Сравнение индексов и цены записи (каждый вариант в откатываемой транзакции) ==="
|
||||
$PSQL -f - < student-tests/track2_indexes.sql
|
||||
|
||||
BIG_CHAT=$($PSQL -t -A -c "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1")
|
||||
echo
|
||||
echo "Самый большой чат: $BIG_CHAT"
|
||||
|
||||
echo
|
||||
echo "=== 3. Состояние источника до бэкапа ==="
|
||||
$PSQL -v big_chat="$BIG_CHAT" -f - < student-tests/track2_verify.sql
|
||||
|
||||
echo
|
||||
echo "=== 4. Бэкап pg_dump -Fc ==="
|
||||
BACKUP_START=$(now_ms)
|
||||
docker compose --env-file .env exec -T postgres pg_dump -U messenger -d messenger -Fc > "$DUMP"
|
||||
BACKUP_END=$(now_ms)
|
||||
echo "backup_seconds=$(elapsed "$BACKUP_START" "$BACKUP_END")"
|
||||
echo "dump_size=$(du -h "$DUMP" | cut -f1)"
|
||||
|
||||
echo
|
||||
echo "=== 5. Запись после бэкапа: граница потери данных ==="
|
||||
$PSQL -c "INSERT INTO messages (id, chat_id, sender_id, text, created_at) SELECT gen_random_uuid(), '$BIG_CHAT', sender_id, convert_to('marker after backup $STAMP', 'UTF8'), clock_timestamp() FROM messages WHERE chat_id = '$BIG_CHAT' LIMIT 1"
|
||||
$PSQL -t -A -c "SELECT 'в источнике маркеров: ' || count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1"
|
||||
|
||||
echo
|
||||
echo "=== 6. Новое хранилище: отдельный контейнер и отдельный том ==="
|
||||
docker volume create "$RVOL" >/dev/null
|
||||
docker run -d --name "$RNAME" \
|
||||
-e POSTGRES_USER=messenger \
|
||||
-e POSTGRES_DB=messenger_restored \
|
||||
-e POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password \
|
||||
-v "$PWD/secrets/postgres_password:/run/secrets/postgres_password:ro" \
|
||||
-v "$RVOL:/var/lib/postgresql/data" \
|
||||
"$IMAGE" >/dev/null
|
||||
i=0
|
||||
while [ "$i" -lt 60 ]; do
|
||||
if docker exec "$RNAME" pg_isready -U messenger -d messenger_restored >/dev/null 2>&1; then break; fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
docker exec "$RNAME" pg_isready -U messenger -d messenger_restored
|
||||
|
||||
echo
|
||||
echo "=== 7. Восстановление в новое хранилище ==="
|
||||
docker cp "$DUMP" "$RNAME:/tmp/restore.dump" >/dev/null
|
||||
RESTORE_START=$(now_ms)
|
||||
docker exec "$RNAME" pg_restore -U messenger -d messenger_restored --no-owner --exit-on-error /tmp/restore.dump
|
||||
RESTORE_END=$(now_ms)
|
||||
echo "restore_seconds=$(elapsed "$RESTORE_START" "$RESTORE_END")"
|
||||
|
||||
echo
|
||||
echo "=== 8. Сверка восстановленной копии ==="
|
||||
$RPSQL -v big_chat="$BIG_CHAT" -f - < student-tests/track2_verify.sql
|
||||
|
||||
echo
|
||||
echo "=== 9. Итог ==="
|
||||
SRC_MD5=$($PSQL -t -A -c "SELECT md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) FROM messages WHERE chat_id = '$BIG_CHAT' AND position(convert_to('marker after backup', 'UTF8') in text) <> 1")
|
||||
DST_MD5=$($RPSQL -t -A -c "SELECT md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) FROM messages WHERE chat_id = '$BIG_CHAT'")
|
||||
SRC_ROWS=$($PSQL -t -A -c "SELECT count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) <> 1")
|
||||
DST_ROWS=$($RPSQL -t -A -c "SELECT count(*) FROM messages")
|
||||
echo "backup_seconds=$(elapsed "$BACKUP_START" "$BACKUP_END") restore_seconds=$(elapsed "$RESTORE_START" "$RESTORE_END")"
|
||||
echo "messages_source_without_marker=$SRC_ROWS messages_restored=$DST_ROWS"
|
||||
echo "big_chat_md5_source=$SRC_MD5"
|
||||
echo "big_chat_md5_restored=$DST_MD5"
|
||||
if [ "$SRC_MD5" = "$DST_MD5" ] && [ "$SRC_ROWS" = "$DST_ROWS" ]; then
|
||||
echo "RESULT: восстановленная копия совпадает с источником на момент бэкапа"
|
||||
else
|
||||
echo "RESULT: расхождение, смотри таблицы выше"
|
||||
exit 1
|
||||
fi
|
||||
MARKERS=$($RPSQL -t -A -c "SELECT count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1")
|
||||
echo "маркеров после бэкапа в восстановленной копии: $MARKERS (ожидается 0: всё, что подтверждено после снимка, в дампе отсутствует)"
|
||||
@@ -0,0 +1,104 @@
|
||||
\set ON_ERROR_STOP on
|
||||
|
||||
SELECT count(*) AS messages_total FROM messages;
|
||||
|
||||
SELECT chat_id AS big_chat, count(*) AS big_rows
|
||||
FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1 \gset
|
||||
|
||||
SELECT created_at AS cur_ts, id AS cur_id
|
||||
FROM messages WHERE chat_id = :'big_chat'
|
||||
ORDER BY created_at, id OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 1 \gset
|
||||
|
||||
\echo '############ Вариант A: messages_history_idx (chat_id, created_at, id) ############'
|
||||
BEGIN;
|
||||
ANALYZE messages;
|
||||
SELECT pg_size_pretty(pg_relation_size('messages_history_idx')) AS index_size;
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
|
||||
ORDER BY created_at, id LIMIT 50;
|
||||
SELECT clock_timestamp() AS q0 \gset
|
||||
SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g,
|
||||
LATERAL (
|
||||
SELECT id FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid)
|
||||
ORDER BY created_at, id LIMIT 50
|
||||
) AS page;
|
||||
SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration;
|
||||
SELECT clock_timestamp() AS t0 \gset
|
||||
WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1),
|
||||
u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%')
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(),
|
||||
c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int],
|
||||
u.ids[1 + floor(array_length(u.ids, 1) * random())::int],
|
||||
convert_to('write cost A ' || g, 'UTF8'), now()
|
||||
FROM generate_series(1, 10000) AS g, c, u;
|
||||
SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration;
|
||||
ROLLBACK;
|
||||
|
||||
\echo '############ Вариант B: только (chat_id) ############'
|
||||
BEGIN;
|
||||
DROP INDEX messages_history_idx;
|
||||
CREATE INDEX messages_chat_only_idx ON messages (chat_id);
|
||||
ANALYZE messages;
|
||||
SELECT pg_size_pretty(pg_relation_size('messages_chat_only_idx')) AS index_size;
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
|
||||
ORDER BY created_at, id LIMIT 50;
|
||||
SELECT clock_timestamp() AS q0 \gset
|
||||
SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g,
|
||||
LATERAL (
|
||||
SELECT id FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid)
|
||||
ORDER BY created_at, id LIMIT 50
|
||||
) AS page;
|
||||
SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration;
|
||||
SELECT clock_timestamp() AS t0 \gset
|
||||
WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1),
|
||||
u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%')
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(),
|
||||
c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int],
|
||||
u.ids[1 + floor(array_length(u.ids, 1) * random())::int],
|
||||
convert_to('write cost B ' || g, 'UTF8'), now()
|
||||
FROM generate_series(1, 10000) AS g, c, u;
|
||||
SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration;
|
||||
ROLLBACK;
|
||||
|
||||
\echo '############ Вариант C: (chat_id, created_at, id) INCLUDE (sender_id, text) ############'
|
||||
BEGIN;
|
||||
DROP INDEX messages_history_idx;
|
||||
CREATE INDEX messages_history_covering_idx ON messages (chat_id, created_at, id) INCLUDE (sender_id, text);
|
||||
ANALYZE messages;
|
||||
SELECT pg_size_pretty(pg_relation_size('messages_history_covering_idx')) AS index_size;
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
|
||||
ORDER BY created_at, id LIMIT 50;
|
||||
SELECT clock_timestamp() AS q0 \gset
|
||||
SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g,
|
||||
LATERAL (
|
||||
SELECT id FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid)
|
||||
ORDER BY created_at, id LIMIT 50
|
||||
) AS page;
|
||||
SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration;
|
||||
SELECT clock_timestamp() AS t0 \gset
|
||||
WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1),
|
||||
u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%')
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(),
|
||||
c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int],
|
||||
u.ids[1 + floor(array_length(u.ids, 1) * random())::int],
|
||||
convert_to('write cost C ' || g, 'UTF8'), now()
|
||||
FROM generate_series(1, 10000) AS g, c, u;
|
||||
SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration;
|
||||
ROLLBACK;
|
||||
|
||||
\echo '############ Схема после эксперимента (ROLLBACK вернул индексы) ############'
|
||||
SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY indexname;
|
||||
@@ -0,0 +1,17 @@
|
||||
\set ON_ERROR_STOP on
|
||||
|
||||
SELECT 'users' AS relation, count(*) AS rows FROM users
|
||||
UNION ALL SELECT 'chats', count(*) FROM chats
|
||||
UNION ALL SELECT 'chat_members', count(*) FROM chat_members
|
||||
UNION ALL SELECT 'messages', count(*) FROM messages
|
||||
UNION ALL SELECT 'sessions', count(*) FROM sessions
|
||||
ORDER BY relation;
|
||||
|
||||
SELECT count(*) AS big_chat_rows,
|
||||
md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) AS big_chat_md5
|
||||
FROM messages WHERE chat_id = :'big_chat';
|
||||
|
||||
SELECT id, created_at, left(encode(text, 'escape'), 40) AS text FROM messages
|
||||
WHERE chat_id = :'big_chat' ORDER BY created_at, id LIMIT 3;
|
||||
|
||||
SELECT count(*) AS marker_rows FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1;
|
||||
Reference in New Issue
Block a user