diff --git a/.dockerignore b/.dockerignore index bc16e556..cac0ba03 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,13 @@ __pycache__ node_modules evidence .DS_Store +*.pyc +.idea +.vscode +student-tests/ +tests/ +contracts/ +examples/ +scripts/ +*.md +Dockerfile.example \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..b3a2146f --- /dev/null +++ b/Dockerfile @@ -0,0 +1,20 @@ +# syntax=docker/dockerfile:1 + +FROM golang:1.22.7-alpine3.20 AS build +WORKDIR /src +COPY src/go.mod src/go.sum ./ +RUN go mod download +COPY src/ ./ +ENV CGO_ENABLED=0 +RUN go build -trimpath -ldflags="-s -w" -o /out/server ./cmd/server + +FROM alpine:3.20 AS runtime +RUN addgroup -S app && adduser -S -G app app +WORKDIR /app +COPY --from=build /out/server /app/server +USER app +EXPOSE 8080 +ENV APP_HOST=0.0.0.0 APP_PORT=8080 +HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=3 \ + CMD wget -q -O /dev/null http://127.0.0.1:8080/health/live || exit 1 +ENTRYPOINT ["/app/server"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..9579f686 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,432 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: **BVT2304 Shiyan** +- Целевая оценка; выбранный трек 5: **5; Трек 1 — согласованность кэша истории** (stale read + cache stampede) +- Commit/PR: **solution/BVT2304-Shiyan** (обновляется по мере PR) +- Использованные источники, библиотеки и помощь ИИ: + - Язык и runtime: **Go 1.22**, только стандартная библиотека `net/http` (без стороннего web-фреймворка) + - `github.com/google/uuid v1.6.0` (MIT) — генерация UUID + - `github.com/jackc/pgx/v5 v5.5.5` (MIT) — драйвер PostgreSQL с пулом соединений + - `github.com/redis/go-redis/v9 v9.5.1` (BSD-2) — Redis-клиент + - `golang.org/x/crypto v0.23.0` (BSD-3) — `scrypt` для KDF паролей + - Образы: `postgres:16-alpine`, `redis:7-alpine` (зафиксированы в `compose.yaml`) + - Помощь ИИ: консультации при проектировании схемы БД, транзакционных границ, политики инвалидации кэша и single-flight защиты. Весь код написан и проверен вручную; публичные `tests/` и `contracts/` не изменялись. + +--- ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +### Prerequisites и версии + +| Компонент | Версия | Назначение | +| --- | --- | --- | +| Docker Desktop + Compose | v2 | запуск стенда (единственный обязательный способ) | +| Go | 1.22+ | только для локальной разработки; в контейнере не требуется | +| Python | 3.9+ | публичные и студенческие тесты (только стандартная библиотека) | +| GNU Make | любой | `make check` / `make test` (Windows — WSL или `choco install make`) | +| postgres | 16-alpine | источник истины | +| redis | 7-alpine | кэш сессий и истории | + +### Локальные secrets / `.env` + +Секреты создаются локально и в Git **не коммитятся** — в репозитории лежит только `.env.example`; `.env` добавлен в `.gitignore`. Значения в отчёте не приводятся как секрет (учебный стенд, значения совпадают с `.env.example`). + +```bash +cp .env.example .env +# Отредактируйте .env — значения должны совпадать с .env.example: +# APP_HOST=0.0.0.0 +# APP_PORT=8080 +# APP_ENV=lab +# SESSION_TTL_SECONDS=3600 +# SESSION_STORE=redis +# CACHE_MODE=versioned +# DATABASE_URL=postgres://messenger:messenger_password@postgres:5432/messenger?sslmode=disable +# REDIS_URL=redis://redis:6379/0 +``` + +### Build и запуск + +```bash +docker compose --env-file .env up -d --build +``` + +Поднимаются три сервиса: + +| Сервис | Образ / сборка | Роль | Volume | +| --- | --- | --- | --- | +| `mtusi-postgres` | `postgres:16-alpine` | источник истины | `mtusi_postgres_data` | +| `mtusi-redis` | `redis:7-alpine` | кэш сессий и истории | `mtusi_redis_data` | +| `mtusi-api` | локальный Dockerfile (multi-stage, non-root) | stateless API, ждёт готовности БД и Redis | — | + +### Миграции + +Запускаются автоматически при старте API (`store.RunMigrations` в `main.go`), отдельная команда оператора не нужна: + +- встроены в бинарник через `//go:embed migrations/*.sql`; +- идемпотентны за счёт `IF NOT EXISTS` — повторный запуск не дублирует таблицы; +- единственная миграция `0001_init.sql` создаёт `users`, `chats`, `chat_members`, `messages`, `sessions` со всеми PK/FK/индексами. + +### Ожидание готовности + +```bash +docker compose ps # все три сервиса должны стать healthy +curl http://localhost:8080/health/ready # 200 {"status":"ok"} +``` + +### Тесты + +```bash +# 1. Офлайн-проверка структуры контракта +make check + +# 2. Публичный smoke против работающего стенда +make test + +# 3. Persistence-сценарий: рестарт API + Postgres + Redis с сохранением volumes +make test-persistence ACTION_SCRIPT=scripts/restart.bat + +# 4. Студенческие проверки уровня 4 +python student-tests/run_tests.py --base-url http://localhost:8080 +python student-tests/failover_tests.py --base-url http://localhost:8080 +scripts\expiry.bat + +# 5. Трек 5: эксперименты кэша (off → naive → versioned → recovery) +scripts\cache_demo.bat + +# 6. EXPLAIN-доказательство индекса (≥10k сообщений) +scripts\explain_demo.bat +``` + +### Действия оператора (что нельзя автоматизировать) + +| Шаг | Действие оператора | +| --- | --- | +| 1 | Создать `.env` из `.env.example` (значения — как в примере) | +| 2 | Поднять стенд и дождаться `healthy` у всех трёх сервисов | +| 3 | Запустить `make check`, затем `make test` | +| 4 | Для persistence-сценария подтвердить, **какие именно процессы/хранилища перезапущены**: `scripts/restart.bat` выполняет `docker compose restart postgres redis api`, то есть перезапускаются контейнер API, контейнер Postgres и контейнер Redis; volumes `mtusi_postgres_data` и `mtusi_redis_data` **не удаляются** | +| 5 | Для failover-проверок вручную останавливать/запускать `redis` и `postgres` (`docker compose stop` / `docker compose start`) и фиксировать время восстановления | +| 6 | Для expiry-теста временно выставить `SESSION_TTL_SECONDS=2`, пересоздать контейнер API, вернуть `3600` | +| 7 | Сохранить terminal output как доказательство (строки `RESULT ...`, `[PASS] ...`) | + +### Безопасная остановка + +```bash +docker compose down # останавливает контейнеры; volumes сохраняются +``` + +### Намеренное удаление учебных данных + +```bash +docker compose down -v # удаляет контейнеры И volumes (данные теряются безвозвратно) +``` + +--- ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +### Схема процессов и хранилищ + +``` +Клиент ──HTTP──► API (Go, stateless, PID 1 в контейнере) + │ + ├──► PostgreSQL 16 (источник истины) + │ volume: mtusi_postgres_data + │ таблицы: users, chats, chat_members, messages, sessions + │ + └──► Redis 7 (кэш сессий + истории) + volume: mtusi_redis_data + роль: ускорение hot path "токен → пользователь" + и чтение истории (с инвалидацией версией) +``` + +### Источник истины + +- **PostgreSQL** — источник истины для всего: пользователи, чаты, участники, сообщения **и сессии**. +- **Redis** — опциональный кэш: при его недоступности API деградирует в postgres-only режим (`log.Warn`), а не отказывает. +- Такое разделение закрывает требование уровня 3 «ещё действительные сессии переживают перезапуск» конструктивно: Postgres volume сохраняется между рестартами, отдельная настройка persistence в Redis не требуется. + +### Транзакционные границы + +| Операция | Транзакция | Гарантии | +| --- | --- | --- | +| `CreateUser` | один INSERT | гонка двух одинаковых `username` → SQLSTATE 23505 (unique violation) → детерминированно маппится в 409 Conflict | +| `UserByCredentials` | один SELECT | неизвестный user и неверный пароль дают **один и тот же** `ErrInvalidLogin` → наружу 401 без раскрытия существования учётки | +| `CreateSession` | SELECT + INSERT | `expires_at = now() + TTL`; TTL не продлевается рестартом | +| `CreateChat` | **составная транзакция**: проверка всех `member_ids` → INSERT `chats` → INSERT `chat_members` → COMMIT | любая ошибка → ROLLBACK: «получата» в БД не бывает | +| `CreateMessage` | транзакция: проверка членства → INSERT | после COMMIT сообщение видимо следующему чтению (read-after-write); в режиме `versioned` — `bumpChatVersion` инвалидирует кэш истории | +| `ListMessages` | одиночный SELECT, keyset | `(created_at, id) > (курсор) LIMIT n+1` использует композитный индекс `messages_history_idx` (доказательство — `scripts/explain_plans.md`) | + +### Ограничения + +- TTL сессии **не продлевается** при рестарте: `expires_at` фиксируется в момент создания. +- Миграции идемпотентны (`IF NOT EXISTS`), но без таблицы версий; для эксплуатации нужен миграционный фреймворк. +- Redis-кэш: TTL ключа сессии = остаток TTL сессии; при logout и expiry ключ инвалидируется. +- `X-User-Id` игнорируется начиная с lab2 (требование README); аутентификация только через Bearer. +- Healthcheck контейнера стучит в `/health/live`; `/health/ready` возвращает 503 при недоступности Postgres (весь обязательный путь зависит от БД). +- TTL кэша истории = 60 с; single-flight действует **внутри одного процесса API**. + +### Что перенесено из lab1 + +- Структура API-слоя: `router.go`, `handlers.go`, `middleware.go`, `helpers.go`, `apperr/`. +- Graceful shutdown, healthcheck, таймауты, middleware-цепочка (requestID → logging → recover → mux). +- Dockerfile (multi-stage, non-root, healthcheck на live). +- `Timestamp` с детерминированной JSON-сериализацией (ровно 3 знака миллисекунд). +- `Page[T]` — дженерик-страница, курсоры base64url со `Scope`. +- Конверт ошибок `apperr.Write`. + +### Что изменено в lab2 + +- In-memory `Store` заменён на PostgreSQL-репозиторий (`store/postgres.go`) + Redis-кэш (`store/cache.go`). +- Аутентификация: `X-User-Id` → Bearer; Basic только на `POST /auth/sessions` (отдельный middleware `basicOnly`). +- Регистрация принимает `password` (хеш через scrypt, формат `scrypt$N$r$p$salt$hash`). +- Добавлены миграции (embed в бинарник, запуск в `main.go` до старта сервера). +- Добавлены handlers `createSession`, `revokeSession` (logout → 204). +- `/health/ready` пингует БД: недоступность → 503. +- Добавлен режим `CACHE_MODE` (off / naive / versioned) для исследования кэша (трек 5). + +### Соответствие переменных `.env.example` реальной конфигурации + +| Переменная | Роль | Дефолт в `.env.example` | Реальное значение в `.env` | +| --- | --- | --- | --- | +| `APP_HOST` | bind-адрес | `0.0.0.0` | `0.0.0.0` | +| `APP_PORT` | порт API | `8080` | `8080` | +| `APP_ENV` | окружение | `lab` | `lab` | +| `SESSION_TTL_SECONDS` | срок жизни сессии | `3600` | `3600` (≥300 для smoke; `2` — только в expiry-тесте) | +| `SESSION_STORE` | `postgres` или `redis` | `postgres` | `redis` | +| `CACHE_MODE` | режим кэша истории | `versioned` | `versioned` (`off` / `naive` — только в экспериментах) | +| `DATABASE_URL` | строка подключения Postgres | — | `postgres://messenger:messenger_password@postgres:5432/messenger?sslmode=disable` | +| `REDIS_URL` | строка подключения Redis | — | `redis://redis:6379/0` | + +--- ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Каждая строка = отдельный заявленный критерий: указана команда/сценарий и наблюдаемый результат (PASS без команды и наблюдения доказательством не считается). -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий README | Команда / сценарий | Наблюдаемый результат | Файл доказательства | +| --- | --- | --- | --- | +| **Уровень 3.** Публичный smoke | `make test` | `PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.` | terminal output | +| **Уровень 3.** Минимум lab1 сохранён с новой аутентификацией | `make test` | smoke проходит health → users → createSession (Basic) → chats → messages → пагинация → logout | terminal output | +| **Уровень 3.** Данные и сессии переживают рестарт без удаления volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.bat` | `PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.` | terminal output + ручные доказательства ниже | +| **Уровень 3.** Подтверждение hook: какие процессы/хранилища перезапущены | `scripts/restart.bat` → `docker compose restart postgres redis api` | перезапущены контейнеры API, Postgres и Redis; volumes `mtusi_postgres_data` и `mtusi_redis_data` не удалены и существуют после рестарта (`docker volume ls`) | terminal output + `docker compose ps` | +| **Уровень 3.** PostgreSQL содержит пользователей, чаты, участников, сообщения | `docker compose exec postgres psql ...` | 5 таблиц существуют и содержат данные: users / sessions / messages | terminal output | +| **Уровень 3.** PK / FK / unique username | `0001_init.sql` | PK на `users.id`, `chats.id`, `messages.(chat_id, id)`; FK с `ON DELETE CASCADE` на `chat_members`, `sessions`, `messages`; `UNIQUE INDEX users_username_key` | `src/internal/store/migrations/0001_init.sql` | +| **Уровень 3.** Миграции выполняются с нуля | `docker compose up --build` (первый запуск) | `running migration 0001_init.sql` в логах API | `docker compose logs api` | +| **Уровень 3.** Миграции перезапускаются без дублирования данных | `docker compose restart api` → логи | та же строка `running migration`, но `IF NOT EXISTS` не создаёт дублей | `docker compose logs api` | +| **Уровень 3.** Составная операция создания чата атомарна | `run_tests.py`: `chat with unknown member -> 400`, `rollback: no partial chat` | PASS: чат не создан, выполнен ROLLBACK | terminal output | +| **Уровень 3.** `make test` и `make test-persistence` проходят | команды выше | оба PASS | terminal output | +| **Уровень 3.** Секреты и volumes не в Git | `git status`, `.gitignore` | `.env` отсутствует среди tracked-файлов | terminal output | +| **Уровень 4.** Redis реально используется для сессий с TTL | `SESSION_STORE=redis` + `docker compose exec redis redis-cli INFO keyspace` | ключи `sess:*` существуют; TTL согласован с `expires_at` в Postgres | terminal output | +| **Уровень 4.** Параметризованные запросы | grep по `store/*.go` | все SQL используют `$1, $2, ...` через pgx; конкатенации строк нет | `src/internal/store/postgres.go` | +| **Уровень 4.** Ограниченный пул и таймауты | чтение `main.go` | `MaxConns=10`, `ConnectTimeout=5s`, `statement_timeout=15000`, `HealthCheckPeriod=10s` | `src/cmd/server/main.go` | +| **Уровень 4.** Гонка регистрации | `run_tests.py`: `race registration: one 201, rest 409` | UNIQUE-ограничение детерминированно разрешает гонку: 1×201 + 9×409 | terminal output | +| **Уровень 4.** Откат составной операции | `run_tests.py`: `rollback: no partial chat` | частичный чат невозможен | terminal output | +| **Уровень 4.** Индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥10k | `scripts\explain_demo.bat` | Index Scan 0.118 ms / buffers hit=4 read=1 против Seq Scan 4.613 ms / buffers hit=383 (≈×39 быстрее, ≈×77 меньше I/O) | `scripts/explain_plans.md` | +| **Уровень 4.** Автоматическая проверка expiry | `scripts\expiry.bat` (`SESSION_TTL_SECONDS=2`) | `EXPIRY CHECKS PASSED`: свежий токен → 200, через 3 с → 401 + `WWW-Authenticate: Bearer`, повторный вход → 201 | terminal output | +| **Уровень 4.** Logout | `run_tests.py`: `logout -> 204`, `revoked token -> 401` | повторное использование отозванного токена → 401 | terminal output | +| **Уровень 4.** Неверный пароль | `run_tests.py`: `wrong password WWW-Authenticate Basic` | PASS: 401 + `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"` | terminal output | +| **Уровень 4.** Недоступность Redis | `failover_tests.py`: `redis down: write 201`, `redis down: read 200` | API деградирует в postgres-only: все операции 200 | terminal output | +| **Уровень 4.** Недоступность Postgres | `failover_tests.py`: `postgres down: ready becomes 503`, `protected request 503`, `anonymous still 401` | `/health/ready` → 503; защищённый запрос → 503 (не 401 и не 200); анонимный по-прежнему 401 | terminal output | +| **Уровень 4.** Basic только на `/auth/sessions` | `run_tests.py`: `Basic on business endpoint -> 401 Bearer` | 401 + `WWW-Authenticate: Bearer` | terminal output | +| **Уровень 4.** `X-User-Id` не даёт доступ | `run_tests.py`: `X-User-Id ignored -> 401` | 401 даже с валидным UUID | terminal output | +| **Трек 5.** Baseline без кэша: каждое чтение = SQL | `scripts\cache_demo.bat`, `CACHE_MODE=off` | `RESULT mode=off reads=100 sql=132 stampede_sql=32`; `[PASS] off: every read hits SQL`; `[PASS] off: concurrent cold reads -> each hits SQL` | terminal output | +| **Трек 5.** Stale read воспроизведён на неинвалидированном кэше | `scripts\cache_demo.bat`, `CACHE_MODE=naive` | `RESULT mode=naive stale_observed=True`; `[PASS] naive: stale read OBSERVED (cache returned old page after write)` | terminal output | +| **Трек 5.** Read-after-write сохранён при инвалидации версией | `scripts\cache_demo.bat`, `CACHE_MODE=versioned` | `[PASS] read-after-write OK`; `[PASS] warm reads from cache` | terminal output | +| **Трек 5.** Single-flight ограничивает cache stampede | 32 конкурентных холодных чтения (`threading.Barrier`), `CACHE_MODE=versioned` | `stampede_sql=1` — ровно один SQL на ключ (`[PASS] single-flight -> exactly 1 SQL`) | terminal output | +| **Трек 5.** Recovery: кэш перестраивается после рестарта Redis | `docker compose restart redis` + read-after-write | `RESULT mode=recovery sql_after_restart=1`; `[PASS] api ready`; `[PASS] session still valid`; `[PASS] history readable`; `[PASS] read-after-write OK`; `[PASS] cache rebuilds` | terminal output | + +### Ручные доказательства persistence (как требует `tests/README.md`) + +- **До рестарта:** `docker compose ps` показывает все три сервиса healthy; `SELECT COUNT(*)` возвращает число пользователей, сессий и сообщений. +- **После `scripts/restart.bat`** (`docker compose restart postgres redis api`): все три сервиса снова healthy, счётчики не уменьшились (добавились только синтетические данные самого теста), volumes `mtusi_postgres_data` и `mtusi_redis_data` существуют. +- **Логи API:** `shutdown signal received` → `server stopped cleanly` → `postgres connected` → `running migration` → `server started`; защищённые эндпоинты отвечают 200 **с тем же Bearer-токеном**, что и до рестарта. + +### EXPLAIN-доказательство индекса (детализация строки уровня 4) + +30 002 сообщения в одном чате, один и тот же запрос keyset-пагинации (первая страница, `LIMIT 51`): + +| Метрика | С индексом `messages_history_idx` | Без индекса | Отношение | +| --- | --- | --- | --- | +| План | `Index Scan using messages_history_idx`, `Index Cond: chat_id AND ROW(created_at, id) > ROW(...)` | `Seq Scan on messages` + `Sort` по всей истории | — | +| Execution Time | **0.118 ms** | **4.613 ms** | **×39 быстрее** | +| Buffers (shared) | **hit=4, read=1** | **hit=383** | **×77 меньше I/O** | +| Строк прочитано | 51 (ровно страница) | 30 002 (вся история) + `Rows Removed by Filter: 520` | ×588 | + +Полные планы: `scripts/explain_plans.md`. Вывод: пагинация использует покрывающий композитный индекс и не сканирует всю историю на страницу. + +--- ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### Гипотеза + +Без кэша каждый `GET /api/v1/chats/{id}/messages` выполняет SQL-запрос, и при конкуренции читателей это нагружает БД. Кэш в Redis способен снять эту нагрузку, но: + +1. без инвалидации нарушается контракт **read-after-write** (клиент видит stale-страницу); +2. без защиты от **cache stampede** конкурентные холодные чтения лавинно бьют в БД (N читателей = N SQL). + +Проверяемое утверждение: версионирование ключа кэша + single-flight сохраняют оба контракта и сокращают число SQL-запросов чтения до 1 на ключ при холодном старте и до 0 при тёплых чтениях. + +### Условия измерения + +| Параметр | Значение | +| --- | --- | +| Hardware | рабочая станция разработчика, Docker Desktop | +| Лимиты контейнеров | CPU/RAM-лимиты **не выставлялись** (локальный учебный стенд) | +| Версии | Go 1.22; `postgres:16-alpine`; `redis:7-alpine` (зафиксированы в `compose.yaml`) | +| Объём данных | 30 002 сообщения в одном чате (+ пользователи, чаты, сессии smoke-сценария) | +| Профиль нагрузки — чтения | `READS=100`: последовательные GET на один чат, один клиент | +| Профиль нагрузки — concurrency | `STAMPEDE=32`: 32 конкурентных холодных чтения, синхронизированных через `threading.Barrier` (одномоментный burst, не постоянный arrival rate) | +| Arrival rate | не задавался: закрытая модель, следующий запрос после ответа предыдущего | +| Длительность / прогрев | фаза `naive` и `versioned` измеряются на прогретом кэше (warm-up чтениями до начала подсчёта); фаза `off` — без кэша, прогрев не требуется | +| Повторы | 1 прогон на фазу; для статистической значимости нужно ≥3 повтора — указано в ограничениях | +| Успешные RPS | напрямую не измерялись; оценка по медиане клиентской latency одного последовательного клиента: ≈1000/23.34 ≈ **43 RPS** (`off`) и ≈1000/25.92 ≈ **39 RPS** (`versioned`) — оценка, а не измерение | +| Ошибки | HTTP-ошибок в фазах кэша нет (все чтения 200, все записи 201); в failover-тестах 401/503 — ожидаемое поведение, а не ошибка | +| CPU / RAM | **не собирались** (`docker stats` не снимался) — TODO для повторного прогона | +| Метрика SQL | `grep sql_list_messages` по `docker compose logs api --since ` | +| Метрика latency | `time.perf_counter()` на клиенте вокруг HTTP-запроса | + +### Режимы кэша (переключаются переменной `CACHE_MODE`, бинарник один) + +| Режим | Поведение кэша | Защита от stale read | Защита от stampede | Назначение в эксперименте | +| --- | --- | --- | --- | --- | +| `off` | кэш выключен | N/A | N/A | baseline: каждое чтение = SQL | +| `naive` | кэш без инвалидации | ❌ отсутствует | ❌ отсутствует | демонстрация проблемы (stale read) | +| `versioned` | кэш с версией чата в ключе + single-flight | ✅ bump версии на COMMIT | ✅ single-flight на ключ | решение: контракты соблюдены | + +### Фазы эксперимента + +| Фаза | Сценарий | Наблюдаемый результат | Чек | +| --- | --- | --- | --- | +| `off` | baseline без кэша | `RESULT mode=off reads=100 sql=132 stampede_sql=32 p50=23.34 p95=44.10 p99=46.98` | `[PASS] off: every read hits SQL`; `[PASS] off: concurrent cold reads -> each hits SQL` | +| `naive` | тёплый кэш + запись + повторное чтение | `RESULT mode=naive stale_observed=True` | `[PASS] naive: stale read OBSERVED (cache returned old page after write)` | +| `versioned` | защищённый кэш: read-after-write + stampede + warm reads | `RESULT mode=versioned reads=100 sql=0 stampede_sql=1 p50=25.92 p95=45.12 p99=47.59` | `[PASS] read-after-write OK`; `[PASS] single-flight -> exactly 1 SQL`; `[PASS] warm reads from cache` | +| `recovery` | `docker compose restart redis` + read-after-write | `RESULT mode=recovery sql_after_restart=1` | `[PASS] api ready`; `[PASS] session still valid`; `[PASS] history readable`; `[PASS] read-after-write OK`; `[PASS] cache rebuilds` | + +### Raw summary (без токенов и секретов) + +```text +RESULT mode=off reads=100 sql=132 stampede_sql=32 p50=23.34 p95=44.10 p99=46.98 +RESULT mode=naive stale_observed=True +RESULT mode=versioned reads=100 sql=0 stampede_sql=1 p50=25.92 p95=45.12 p99=47.59 +RESULT mode=recovery sql_after_restart=1 +EXPIRY CHECKS PASSED +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +``` + +Все строки получены из terminal output скриптов `scripts\cache_demo.bat`, `scripts\expiry.bat`, `make test`, `make test-persistence`; токены сессий и значения `.env` в них не попадают и в отчёте не приводятся. + +### Счётчик SQL — главная метрика трека + +| Режим | reads | sql (всего) | stampede_sql (32 холодных) | read-after-write | +| --- | --- | --- | --- | --- | +| `off` | 100 | 132 | **32** (каждый miss = SQL) | N/A | +| `naive` | — | — | — | **FAIL** (stale read OBSERVED) | +| `versioned` | 100 | **0** (все тёплые из кэша) | **1** (single-flight) | **OK** | +| `recovery` | 2 | 1 (rebuild кэша) | — | **OK** | + +### Latency p50/p95/p99 (ms, клиентское измерение) + +| Режим | p50 | p95 | p99 | +| --- | --- | --- | --- | +| `off` | 23.34 | 44.10 | 46.98 | +| `versioned` | 25.92 | 45.12 | 47.59 | + +### Качественные наблюдения + +- **Stale read в `naive`:** прогретый кэш + успешная запись + повторное чтение → клиент видит старую страницу (нового сообщения нет в `items`). Это конструктивная демонстрация проблемы, которую решает `versioned`. +- **Stampede в `off`:** 32 конкурентных холодных чтения = 32 SQL-запроса; без кэша stampede ничем не ограничен. +- **Stampede-защита в `versioned`:** те же 32 чтения = ровно 1 SQL — single-flight схлопывает их в один SELECT. +- **Read-after-write в `versioned`:** после успешной записи `bumpChatVersion` меняет версию чата; следующий GET строит ключ с новой версией → cache miss → свежий SELECT → кэш перестраивается. +- **Recovery:** `docker compose restart redis` теряет все кэш-ключи, но API продолжает работать через SQL; источник истины (сессии в Postgres) не теряется; кэш перестраивается на следующих чтениях. + +### Реализация защиты + +| Компонент | Файл | Принцип | +| --- | --- | --- | +| Версионирование ключа кэша | `store/cache.go`, `HistoryCacheKey` | ключ `hist:v:::`, где N = `ChatVersion` из Redis | +| Инвалидация на COMMIT | `store/postgres.go`, `CreateMessage` | после успешного `tx.Commit` вызывается `bumpChatVersion(ctx, chatID)` → INCR счётчика; ключи с v 401`, `expired WWW-Authenticate Bearer` | N/A | +| Logout (`DELETE /auth/sessions/current`) | 204; повторное использование токена → 401 | PASS: `logout -> 204`, `revoked token -> 401` | N/A | +| Рестарт API + Postgres + Redis (`scripts/restart.bat`) | volumes сохранены, данные и сессии живы | `PASS: persistence preserved confirmed data and existing session` | мгновенно; volumes `mtusi_postgres_data` и `mtusi_redis_data` не удалены | +| Stampede: 32 конкурентных холодных чтения, режим `off` | каждый miss = SQL | `stampede_sql=32` (ожидаемо для baseline) | N/A | +| Stampede: 32 конкурентных холодных чтения, режим `versioned` | single-flight → 1 SQL | `stampede_sql=1` | N/A | + +--- ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +### Какие отказы выдерживаются + +- Перезапуск API-контейнера: данные и сессии сохраняются (Postgres volume). +- Перезапуск Postgres-контейнера: данные сохраняются (volume). +- Перезапуск Redis-контейнера: сессии сохраняются (источник истины — Postgres), кэш перестраивается. +- SIGTERM → graceful shutdown за ~0.5 с (< 10 с бюджета `docker stop`). +- Потеря кэш-ключа Redis: деградация в SQL, не отказ. +- Stampede внутри процесса API: single-flight ограничивает нагрузку на БД. +- Истечение сессии: токен помечается как `ErrNotFound`, ленивая чистка просрочки. + +### Какие отказы НЕ выдерживаются (честно указано) + +- Потеря Docker-host: один host не обеспечивает HA (COURSE.md). +- Потеря volume Postgres: данные будут потеряны (репликации в lab2 нет; тема lab3+). +- Отказ Postgres: API возвращает 503, но не обслуживает запросы (read-replica в lab2 нет). +- Stampede **между** процессами API при горизонтальном масштабировании — тема lab3. +- S3-вложения, фоновая обработка, OTel, Argon2id — темы следующих лабораторных. + +### Что не реализовано (темы следующих лаб) + +- Idempotency-Key для POST сообщений (lab3). +- X-Instance-Id в ответах (lab3). +- Балансировщик и ≥2 API-реплики (lab3). +- S3-хранилище вложений (lab4). +- Брокер и worker для преобразования изображений (lab5). +- OTel-observability (lab6). +- Argon2id вместо scrypt (lab7 требует Argon2id; текущая схема `scrypt$N$r$p$salt$hash` позволяет мигрировать без поломки старых паролей — параметры едут вместе с хэшем). + +### Где учебное упрощение + +- Пароли хешируются `scrypt` с параметрами N=32768, r=8, p=1, keyLen=32 — достаточно для учебного стенда, но в production параметры подбираются бенчмарком под целевое железо. +- Курсоры хранятся как base64url-encoded JSON; в production их подписывали бы HMAC, чтобы исключить подделку клиентом. +- `ChatForUser` использует correlated subquery `(SELECT array_agg(cm.user_id) ...)`; для больших чатов эффективнее JOIN с LIMIT. +- Миграции запускаются через embed в бинарник; в production нужен отдельный инструмент с таблицей версий (goose, golang-migrate). +- Single-flight и TTL кэша (60 с) рассчитаны на один процесс API и учебный профиль нагрузки. + +### Что подтверждено, а что остаётся гипотезой + +**Подтверждено измерениями:** + +- Кэш с инвалидацией версией сохраняет контракт read-after-write (`versioned: read-after-write OK`). +- Single-flight ограничивает stampede внутри процесса ровно одним SQL на ключ (`versioned: stampede_sql=1`). +- В warm-режиме кэш полностью снимает SQL-нагрузку чтения (`versioned: sql=0` на 100 чтений). +- Деградация при Redis down работает корректно (`failover: redis down: ready stays 200, write 201, read 200`). +- Источник истины Postgres переживает restart Redis без потери сессий (`recovery: session still valid`). +- Композитный индекс истории даёт выигрыш на ≥10k сообщений: 0.118 ms против 4.613 ms, hit=4 read=1 против hit=383. + +**Остаётся гипотезой (до бенчмарка внутри процесса):** + +- Реальный выигрыш latency p50/p95/p99 от кэша: на локальном стенде с HTTP-оверхедом разница не выражена (23.34 vs 25.92 ms p50), требуется бенчмарк без HTTP-слоя. +- Поведение stampede-защиты при нескольких репликах API (нужен распределённый single-flight или Redis-lock) — проверка возможна только в lab3. +- Ресурсная цена кэша (CPU/RAM API и Redis под нагрузкой) — измерения не собирались. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..fec1847d --- /dev/null +++ b/compose.yaml @@ -0,0 +1,63 @@ +services: + postgres: + image: postgres:16-alpine + container_name: mtusi-postgres + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD: messenger_password # для локальной разработки; в production — secrets + ports: + - "127.0.0.1:5432:5432" + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger"] + interval: 5s + timeout: 5s + retries: 5 + + redis: + image: redis:7-alpine + container_name: mtusi-redis + ports: + - "127.0.0.1:6379:6379" + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 5 + + api: + build: + context: . + dockerfile: Dockerfile + container_name: mtusi-api + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + ports: + - "127.0.0.1:8080:8080" + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + APP_ENV: lab + DATABASE_URL: postgres://messenger:messenger_password@postgres:5432/messenger?sslmode=disable + REDIS_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + CACHE_MODE: ${CACHE_MODE:-versioned} + SESSION_STORE: ${SESSION_STORE:-redis} + healthcheck: + test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://localhost:8080/health/ready"] + interval: 5s + timeout: 3s + retries: 5 + +volumes: + postgres_data: + name: mtusi_postgres_data + redis_data: + name: mtusi_redis_data \ No newline at end of file diff --git a/evidence/cache_track.md b/evidence/cache_track.md new file mode 100644 index 00000000..15fb78ea --- /dev/null +++ b/evidence/cache_track.md @@ -0,0 +1,26 @@ +# Трек 5: согласованность кэша истории — замеры и демонстрации +Сформировано: 07.10.2026 18:32:18,01 + +[PASS] off: concurrent cold reads -> each hits SQL (stampede without cache) +[PASS] off: every read hits SQL +RESULT mode=off reads=100 sql=132 stampede_sql=32 p50=23.34 p95=44.1 p99=46.98 +PHASE off DONE + +[PASS] naive: stale read OBSERVED (cache returned old page after write) +RESULT mode=naive stale_observed=True +PHASE naive DONE + +[PASS] versioned: read-after-write OK (no stale) +[PASS] versioned: single-flight -> exactly 1 SQL on cold key +[PASS] versioned: warm reads served from cache +RESULT mode=versioned reads=100 sql=0 stampede_sql=1 p50=25.92 p95=45.12 p99=47.59 +PHASE versioned DONE + +[PASS] recovery: api ready after redis restart +[PASS] recovery: session still valid (source of truth = postgres) +[PASS] recovery: history readable after cache loss +[PASS] recovery: read-after-write OK with rebuilt cache +[PASS] recovery: cache rebuilds (1 sql for 2 reads) +RESULT mode=recovery sql_after_restart=1 +PHASE recovery DONE + diff --git a/scripts/cache_demo.bat b/scripts/cache_demo.bat new file mode 100644 index 00000000..6831ba9b --- /dev/null +++ b/scripts/cache_demo.bat @@ -0,0 +1,60 @@ +@echo off +setlocal enabledelayedexpansion +chcp 65001 >nul +cd /d "%~dp0.." + +set OUT=evidence\cache_track.md +if not exist evidence mkdir evidence +> %OUT% echo # Трек 5: согласованность кэша истории — замеры и демонстрации +>> %OUT% echo Сформировано: %DATE% %TIME% +>> %OUT% echo. + +echo [1/5] Baseline: CACHE_MODE=off +set CACHE_MODE=off +docker compose up -d api >nul +timeout /t 12 /nobreak >nul +python student-tests\cache_consistency.py --phase off > evidence\phase_off.txt 2>&1 +if errorlevel 1 ( type evidence\phase_off.txt & goto :fail ) +type evidence\phase_off.txt +type evidence\phase_off.txt >> %OUT% +echo. >> %OUT% + +echo [2/5] Naive cache: CACHE_MODE=naive +set CACHE_MODE=naive +docker compose up -d api >nul +timeout /t 12 /nobreak >nul +python student-tests\cache_consistency.py --phase naive > evidence\phase_naive.txt 2>&1 +if errorlevel 1 ( type evidence\phase_naive.txt & goto :fail ) +type evidence\phase_naive.txt +type evidence\phase_naive.txt >> %OUT% +echo. >> %OUT% + +echo [3/5] Protected cache: CACHE_MODE=versioned +set CACHE_MODE=versioned +docker compose up -d api >nul +timeout /t 12 /nobreak >nul +python student-tests\cache_consistency.py --phase versioned > evidence\phase_versioned.txt 2>&1 +if errorlevel 1 ( type evidence\phase_versioned.txt & goto :fail ) +type evidence\phase_versioned.txt +type evidence\phase_versioned.txt >> %OUT% +echo. >> %OUT% + +echo [4/5] Recovery after redis restart +python student-tests\cache_consistency.py --phase recovery > evidence\phase_recovery.txt 2>&1 +if errorlevel 1 ( type evidence\phase_recovery.txt & goto :fail ) +type evidence\phase_recovery.txt +type evidence\phase_recovery.txt >> %OUT% +echo. >> %OUT% + +echo [5/5] Restoring default CACHE_MODE +set CACHE_MODE= +docker compose up -d api >nul +timeout /t 12 /nobreak >nul +echo Done: %OUT% +exit /b 0 + +:fail +echo PHASE FAILED — see evidence\phase_*.txt +set CACHE_MODE= +docker compose up -d api >nul +exit /b 1 \ No newline at end of file diff --git a/scripts/expiry.bat b/scripts/expiry.bat new file mode 100644 index 00000000..2ad6694c --- /dev/null +++ b/scripts/expiry.bat @@ -0,0 +1,11 @@ +@echo off +cd /d "%~dp0.." +echo [expiry] starting api with SESSION_TTL_SECONDS=3 +set SESSION_TTL_SECONDS=3 +docker compose up -d api +timeout /t 12 /nobreak >nul +python student-tests\expiry_checks.py --base-url http://localhost:8080 +set SESSION_TTL_SECONDS= +echo [expiry] restoring default TTL +docker compose up -d api +timeout /t 10 /nobreak >nul \ No newline at end of file diff --git a/scripts/explain_demo.bat b/scripts/explain_demo.bat new file mode 100644 index 00000000..5d2f1e6a --- /dev/null +++ b/scripts/explain_demo.bat @@ -0,0 +1,100 @@ +@echo off +setlocal enabledelayedexpansion +chcp 65001 >nul +cd /d "%~dp0.." + +rem Артефакты складываем рядом с bat-файлом +set MD=%~dp0explain_plans.md +set PW=%~dp0plan_with_index.txt +set PN=%~dp0plan_no_index.txt + +echo === EXPLAIN demo for messages_history_idx === +echo. + +echo [1/8] Fetch chat and member ids... +for /f "usebackq tokens=*" %%i in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT id FROM chats ORDER BY created_at LIMIT 1;"`) do set CHAT=%%i +for /f "usebackq tokens=*" %%i in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT user_id FROM chat_members WHERE chat_id='%CHAT%' LIMIT 1;"`) do set SENDER=%%i +echo Chat: %CHAT% +echo Sender: %SENDER% + +if not exist student-tests\seed.sql ( + echo ERROR: student-tests\seed.sql not found + exit /b 1 +) +if not exist student-tests\explain.sql ( + echo ERROR: student-tests\explain.sql not found + exit /b 1 +) +echo. + +echo [2/8] Seeding 10000 messages... +type student-tests\seed.sql | docker compose exec -T postgres psql -U messenger -d messenger -v chat=%CHAT% -v sender=%SENDER% -f - +if errorlevel 1 ( + echo ERROR: seed failed + exit /b 1 +) +for /f "usebackq tokens=*" %%c in (`docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT count(*) FROM messages WHERE chat_id='%CHAT%';"`) do set ROWS=%%c +echo Seed done. Rows in chat: %ROWS% +echo. + +echo [3/8] ANALYZE messages (свежая статистика для планировщика)... +docker compose exec postgres psql -U messenger -d messenger -c "ANALYZE messages;" +echo. + +echo [4/8] Index presence check (ожидаем messages_history_idx в списке): +docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT indexname FROM pg_indexes WHERE tablename='messages';" +echo. + +echo [5/8] EXPLAIN WITH index -^> %PW% +type student-tests\explain.sql | docker compose exec -T postgres psql -U messenger -d messenger -v chat=%CHAT% -f - > %PW% +type %PW% +echo. + +echo [6/8] Dropping index... +docker compose exec postgres psql -U messenger -d messenger -c "DROP INDEX IF EXISTS messages_history_idx;" +echo. + +echo [7/8] EXPLAIN WITHOUT index -^> %PN% +type student-tests\explain.sql | docker compose exec -T postgres psql -U messenger -d messenger -v chat=%CHAT% -f - > %PN% +type %PN% +echo. + +echo [8/8] Restoring index + assembling %MD% ... +docker compose exec postgres psql -U messenger -d messenger -c "CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id);" +docker compose exec postgres psql -U messenger -d messenger -c "ANALYZE messages;" + +> %MD% echo # EXPLAIN-планы истории сообщений: messages_history_idx +>> %MD% echo. +>> %MD% echo Сформировано: %DATE% %TIME% +>> %MD% echo Чат: %CHAT% +>> %MD% echo Сообщений в чате: %ROWS% +>> %MD% echo Статистика: ANALYZE messages выполнен после сева и после восстановления индекса. +>> %MD% echo Запрос: keyset-пагинация первой страницы, LIMIT 51, курсор = начало времён. +>> %MD% echo. +>> %MD% echo ## План С индексом messages_history_idx +>> %MD% echo. +>> %MD% echo ```text +type %PW% >> %MD% +>> %MD% echo ``` +>> %MD% echo. +>> %MD% echo Ожидаемая подпись: Index Scan using messages_history_idx, Index Cond содержит +>> %MD% echo chat_id и ROW^(created_at, id^) ^> ROW^(...^); Buffers — единицы/десятки страниц. +>> %MD% echo. +>> %MD% echo ## План БЕЗ индекса: контрольный прогон +>> %MD% echo. +>> %MD% echo ```text +type %PN% >> %MD% +>> %MD% echo ``` +>> %MD% echo. +>> %MD% echo Ожидаемая подпись: Sort + Seq Scan on messages или Bitmap Heap Scan по pkey +>> %MD% echo с фильтром по всей истории; Buffers заметно больше, Execution Time выше. +>> %MD% echo. +>> %MD% echo ## Вывод +>> %MD% echo Индекс messages_history_idx покрывает запрос keyset-пагинации: с ним план +>> %MD% echo читает только нужные строки через Index Scan по ^(chat_id, created_at, id^), +>> %MD% echo без него планировщик вынужден выбирать всю историю чата и сортировать её. +>> %MD% echo Пагинация не выполняет полный scan истории на каждую страницу. +echo Done: %MD% +echo. +echo === EXPLAIN demo finished === +endlocal \ No newline at end of file diff --git a/scripts/explain_plans.md b/scripts/explain_plans.md new file mode 100644 index 00000000..fa03a187 --- /dev/null +++ b/scripts/explain_plans.md @@ -0,0 +1,60 @@ +# EXPLAIN-планы истории сообщений: messages_history_idx + +Сформировано: 07.10.2026 17:59:48,83 +Чат: 1781106d-bfbe-4064-9ab4-a99f955636b0 +Сообщений в чате: 30002 +Статистика: ANALYZE messages выполнен после сева и после восстановления индекса. +Запрос: keyset-пагинация первой страницы, LIMIT 51, курсор = начало времён. + +## План С индексом messages_history_idx + +```text + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=0.41..5.06 rows=51 width=65) (actual time=0.049..0.059 rows=51 loops=1) + Buffers: shared hit=4 read=1 + -> Index Scan using messages_history_idx on messages (cost=0.41..2732.85 rows=30002 width=65) (actual time=0.048..0.055 rows=51 loops=1) + Index Cond: ((chat_id = '1781106d-bfbe-4064-9ab4-a99f955636b0'::uuid) AND (ROW(created_at, id) > ROW('2020-01-01 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid))) + Buffers: shared hit=4 read=1 + Planning: + Buffers: shared hit=109 + Planning Time: 0.864 ms + Execution Time: 0.118 ms +(9 rows) + +``` + +Ожидаемая подпись: Index Scan using messages_history_idx, Index Cond содержит +chat_id и ROW(created_at, id) > ROW(...); Buffers — единицы/десятки страниц. + +## План БЕЗ индекса: контрольный прогон + +```text + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=1912.07..1912.19 rows=51 width=65) (actual time=4.535..4.541 rows=51 loops=1) + Buffers: shared hit=383 + -> Sort (cost=1912.07..1987.07 rows=30002 width=65) (actual time=4.533..4.536 rows=51 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 38kB + Buffers: shared hit=383 + -> Seq Scan on messages (cost=0.00..911.14 rows=30002 width=65) (actual time=0.010..2.480 rows=30002 loops=1) + Filter: ((chat_id = '1781106d-bfbe-4064-9ab4-a99f955636b0'::uuid) AND (ROW(created_at, id) > ROW('2020-01-01 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid))) + Rows Removed by Filter: 520 + Buffers: shared hit=377 + Planning: + Buffers: shared hit=87 dirtied=1 + Planning Time: 0.536 ms + Execution Time: 4.613 ms +(14 rows) + +``` + +Ожидаемая подпись: Sort + Seq Scan on messages или Bitmap Heap Scan по pkey +с фильтром по всей истории; Buffers заметно больше, Execution Time выше. + +## Вывод +Индекс messages_history_idx покрывает запрос keyset-пагинации: с ним план +читает только нужные строки через Index Scan по (chat_id, created_at, id), +без него планировщик вынужден выбирать всю историю чата и сортировать её. +Пагинация не выполняет полный scan истории на каждую страницу. diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..aa857eb3 --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,10 @@ +#!/bin/sh +set -eu + + +cd "$(dirname "$0")/.." + +echo "Restarting all services (preserving volumes)..." +docker compose restart postgres redis api + +echo "Restart completed. Waiting for readiness is done by test harness." \ No newline at end of file diff --git a/scripts/restart.example.sh b/scripts/restart.example.sh index 967e9512..7a359dd3 100755 --- a/scripts/restart.example.sh +++ b/scripts/restart.example.sh @@ -1,10 +1,10 @@ #!/bin/sh set -eu -# TODO: copy to restart.sh and implement using YOUR compose/stack services. +# TODO: copy to restart.bat and implement using YOUR compose/stack services. # Restart API and ALL used state stores (DB, sessions, S3, broker as applicable). # Preserve persistent volumes and schema/data; never down -v / flush / re-seed. # Allow operator unseal if required in lab7; do not print credentials. # Exit 0 only after the intended action; test waits for API readiness separately. printf '%s -' 'TODO: implement restart.sh for your infrastructure' >&2 +' 'TODO: implement restart.bat for your infrastructure' >&2 exit 2 diff --git a/src/DEMO2.md b/src/DEMO2.md new file mode 100644 index 00000000..363bd961 --- /dev/null +++ b/src/DEMO2.md @@ -0,0 +1,312 @@ +# Демонстрация — лабораторная 2 (PostgreSQL, сессии, Redis-кэш) + +**Автор, группа:** BVT2304 Shiyan +**Целевая оценка:** 5 (уровни 3 + 4 + Трек 1 «Согласованность кэша») +**Стенд:** Windows + Docker Desktop, PowerShell; все команды выполняются из корня репозитория. +**Секреты:** `.env` создаётся локально из `.env.example` и НЕ коммитится. Токены в командах ниже — подстановочные (`$T`), в Git не попадают. + +Документ проводит защиту по сценарию README lab2: миграции к пустому volume → пользователи/вход/сообщение → persistence с токеном в памяти → expiry → роль Redis и ошибки зависимостей → план SQL → эксперимент трека 5. Каждый шаг: команда → ожидаемый вывод → что это доказывает. + +--- + +## Шаг 0. Чистый старт: миграции к пустому volume + +```powershell +cd C:\Users\maksimator\GolandProjects\mtusi2026lab2 + +# НАМЕРЕННОЕ удаление учебных данных (volume): доказываем, что схема строится с нуля +docker compose down -v + +# Сборка и запуск всего стенда из репозитория +docker compose --env-file .env up -d --build + +# Готовность: все три сервиса healthy +docker compose ps + +# Миграции применились к пустому volume +docker compose logs api --tail 12 +``` + +**Ожидаемый вывод:** + +``` +mtusi-api ... Up (healthy) +mtusi-postgres ... Up (healthy) +mtusi-redis ... Up (healthy) + +{"level":"INFO","msg":"postgres connected"} +{"level":"INFO","msg":"running migration","file":"0001_init.sql"} +{"level":"INFO","msg":"redis connected"} +{"level":"INFO","msg":"server started","addr":"0.0.0.0:8080","pid":1} +``` + +```powershell +curl.exe -s http://localhost:8080/health/ready +curl.exe -s http://localhost:8080/health/live +``` + +Ожидаемо: `{"status":"ok"}` дважды. + +**Что доказывает:** схема (users, chats, chat_members, messages, sessions + PK/FK/UNIQUE/индексы) создаётся версионируемой миграцией `0001_init.sql`, встроенной в бинарник (`go:embed`), к полностью пустому volume. Повторный рестарт не дублирует данные (`IF NOT EXISTS`). + +--- + +## Шаг 1. Регистрация, вход (Basic → Bearer), пароли + +```powershell +# Регистрация: password принимается ТОЛЬКО на входе (writeOnly) +Invoke-RestMethod -Uri http://localhost:8080/api/v1/users -Method Post -ContentType "application/json" -Body '{"username":"alice","display_name":"Alice","password":"Example-only-not-a-real-secret-123"}' + +Invoke-RestMethod -Uri http://localhost:8080/api/v1/users -Method Post -ContentType "application/json" -Body '{"username":"bob","display_name":"Bob","password":"Example-only-not-a-real-secret-12773"}' +``` + +Ожидаемо: `201` и `User` БЕЗ полей password/password_hash: + +```json +{"id":"...","username":"alice","display_name":"Алиса","created_at":"...Z"} +``` + +```powershell +# Вход: ТОЛЬКО Basic на /auth/sessions; ответ — opaque Bearer-токен +curl.exe -s -X POST -u "alice:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions +``` + +Ожидаемо: `201`: + +```json +{"token":"<43 символа base64url>","token_type":"Bearer","expires_at":"...Z","user":{...}} +``` + +```powershell +# Неверный пароль: 401 + WWW-Authenticate: Basic (не раскрываем существование учётки) +curl.exe -s -i -X POST -u "alice:Wrong-password-999" http://localhost:8080/api/v1/auth/sessions + +# Неизвестный пользователь: ТОТ ЖЕ ответ 401 + тот же заголовок +curl.exe -s -i -X POST -u "nosuchuser000:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions + +# Пароль в БД: только хэш KDF, plaintext отсутствует +docker compose exec postgres psql -U messenger -d messenger -tAc "SELECT username, left(password_hash, 30) FROM users WHERE username='alice';" +``` + +Ожидаемо: оба входа → `HTTP/1.1 401` + `Www-Authenticate: Basic realm="messenger", charset="UTF-8"`; в БД строка вида `alice|scrypt$32768$8$1$$...`. + +**Что доказывает:** пароль хешируется библиотечным password KDF (scrypt), не SHA-256 и не plaintext; неверные и неизвестные credentials неразличимы; токен непрозрачный (не username/UUID/JWT), энтропия 256 бит (32 байта `crypto/rand`). + +--- + +## Шаг 2. Защищённый API: Bearer, доступ к чату, пагинация + +```powershell +# Сохраняем токен в переменную PowerShell (в Git не попадает) +$s = curl.exe -s -X POST -u "alice:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json +$T = $s.token + +# Без токена: 401 + WWW-Authenticate: Bearer +curl.exe -s -i http://localhost:8080/api/v1/users/me + +# X-User-Id с lab2 ИГНОРИРУЕТСЯ: доступа не даёт +curl.exe -s -i http://localhost:8080/api/v1/users/me -H "X-User-Id: $($s.user.id)" + +# Basic на бизнес-endpoint: 401 + WWW-Authenticate: Bearer +curl.exe -s -i http://localhost:8080/api/v1/users/me -u "alice:Example-only-not-a-real-secret-123" + +# С токеном: 200 +curl.exe -s http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T" +``` + +```powershell +# Второй пользователь и чат (вызывающий обязан быть в member_ids) +$b = curl.exe -s -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" -d "{\"username\":\"bob\",\"display_name\":\"Боб\",\"password\":\"Example-only-not-a-real-secret-123\"}" | ConvertFrom-Json +$bs = curl.exe -s -X POST -u "bob:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json +$BT = $bs.token + +$chat = curl.exe -s -X POST http://localhost:8080/api/v1/chats -H "Authorization: Bearer $T" -H "Content-Type: application/json" -d "{\"title\":\"Проект по ВНП\",\"member_ids\":[\"$($s.user.id)\",\"$($b.id)\"]}" | ConvertFrom-Json + +# Сообщения и история (created_at, id) по возрастанию +curl.exe -s -X POST http://localhost:8080/api/v1/chats/$($chat.id)/messages -H "Authorization: Bearer $T" -H "Content-Type: application/json" -d "{\"text\":\"Привет, Боб!\"}" +curl.exe -s "http://localhost:8080/api/v1/chats/$($chat.id)/messages?limit=50" -H "Authorization: Bearer $BT" + +# Посторонний (carol) получает 404, а не 403: существование чужого чата не раскрывается +$c = curl.exe -s -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" -d "{\"username\":\"carol\",\"display_name\":\"Кэрол\",\"password\":\"Example-only-not-a-real-secret-123\"}" | ConvertFrom-Json +$cs = curl.exe -s -X POST -u "carol:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json +curl.exe -s -i http://localhost:8080/api/v1/chats/$($chat.id) -H "Authorization: Bearer $($cs.token)" +``` + +Ожидаемо: `401` с `Www-Authenticate: Bearer realm="messenger"` в трёх негативных случаях; `200` с токеном; `201` на сообщения; история отсортирована; у carol — `404`. + +**Что доказывает:** аутентификация (Bearer → сессия → пользователь) отделена от авторизации (участие в чате); списки содержат только доступные объекты; контракт ошибок соблюдён. + +--- + +## Шаг 3. Persistence: токен живёт только в памяти процесса, рестарт всех хранилищ + +```powershell +# Публичный persistence-тест: создаёт данные и сессию, держит токен в памяти, +# вызывает hook, после готовности читает ТЕ ЖЕ данные ТЕМ ЖЕ токеном +python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080 +``` + +Ожидаемо: `PASS: persistence preserved confirmed data and existing session.` + +Ручное подтверждение объёма hook (требование tests/README.md — показать, ЧТО перезапускалось): + +```powershell +docker compose ps # ДО: все healthy +scripts\restart.bat # hook: docker compose restart postgres redis api +docker compose ps # ПОСЛЕ: uptime сбросился, все healthy +docker volume ls | Select-String mtusi # volumes НЕ удалены: mtusi_postgres_data, mtusi_redis_data +docker compose logs api --tail 8 # shutdown signal received -> server stopped cleanly -> server started +``` + +```powershell +# Тот же токен после рестарта: 200 (сессия пережила рестарт, TTL не продлился) +curl.exe -s -o NUL -w "%{http_code}" http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T" + +# Logout: 204 без тела; повтор с отозванным токеном: 401 +curl.exe -s -o NUL -w "%{http_code}" -X DELETE http://localhost:8080/api/v1/auth/sessions/current -H "Authorization: Bearer $T" +curl.exe -s -i http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T" +``` + +Ожидаемо: `200`, затем `204`, затем `401` + `Www-Authenticate: Bearer realm="messenger"`. + +**Что доказывает:** пользователи, чаты, сообщения и действительные сессии переживают перезапуск API и ОБОИХ хранилищ с сохранёнными volumes; источник истины — PostgreSQL (volume), API stateless. + +--- + +## Шаг 4. Expiry при коротком TTL + +```powershell +scripts\expiry.bat +``` + +Скрипт поднимает API с `SESSION_TTL_SECONDS=2`, прогоняет `student-tests/expiry_checks.py` и возвращает дефолтный TTL. Ожидаемо: + +``` +[PASS] login 201 with TTL=2 +[PASS] fresh token 200 +[PASS] expired token -> 401 +[PASS] expired WWW-Authenticate Bearer +[PASS] re-login after expiry 201 +EXPIRY CHECKS PASSED +``` + +**Что доказывает:** срок жизни сессии управляется `SESSION_TTL_SECONDS`; истёкший токен → 401 с корректным заголовком; TTL не продлевается рестартом. + +--- + +## Шаг 5. Уровень 4: роль Redis и ошибки зависимостей + +```powershell +python student-tests/failover_tests.py --base-url http://localhost:8080 +``` + +Ожидаемо: + +``` +[PASS] redis down: ready stays 200 (cache optional) +[PASS] redis down: auth via postgres 200 +[PASS] redis down: write 201 +[PASS] redis down: read 200 +[PASS] redis back: ready 200 +[PASS] postgres down: ready becomes 503 +[PASS] postgres down: protected request 503 (not 200/401) +[PASS] postgres down: anonymous still 401 +[PASS] postgres back: ready 200 +[PASS] postgres back: same session valid 200 +ALL FAILOVER TESTS PASSED +``` + +**Роль Redis (для защиты):** кэш сессий и кэш истории; источник истины — PostgreSQL. Политика expiry: TTL кэш-ключа сессии = остаток `expires_at`; инвалидация при logout и при истечении. Политика инвалидации истории: версия чата в ключе кэша (Шаг 7). При потере Redis приложение деградирует в SQL (warn в логах), не отказывает и НЕ принимает анонимный запрос как доверенный: при потере Postgres защищённый запрос → 503, аноним → 401. + +Дополнительно — гонка регистрации и rollback составной операции (уровень 4): + +```powershell +python student-tests/run_tests.py --base-url http://localhost:8080 +``` + +Ключевые строки: `[PASS] race registration: one 201, rest 409` (UNIQUE-ограничение детерминированно решает гонку), `[PASS] rollback: no partial chat` (транзакция создания чата атомарна). + +--- + +## Шаг 6. Уровень 4: план SQL (EXPLAIN ANALYZE BUFFERS, ≥10k сообщений) + +```powershell +scripts\explain_demo.bat +Get-Content scripts\explain_plans.md +``` + +Сев 10 000 сообщений (итого 30 002 в чате), `ANALYZE`, два плана одного keyset-запроса: + +| Метрика | С индексом `messages_history_idx` | Без индекса | +|---|---|---| +| План | `Index Scan using messages_history_idx`, Index Cond: `chat_id AND ROW(created_at,id) > ROW(...)` | `Seq Scan on messages` (30 002 строк) + `Sort` | +| Buffers | `shared hit=4 read=1` | `shared hit=383` | +| Execution Time | **0.118 ms** | **4.613 ms** | + +**Что доказывает:** индекс `(chat_id, created_at, id)` покрывает запрос пагинации; страница читает только нужные строки, полный scan истории на страницу не выполняется. + +--- + +## Шаг 7. Уровень 5, Трек 1: согласованность кэша истории + +```powershell +scripts\cache_demo.bat +Get-Content evidence\cache_track.md +``` + +Эксперимент переключает `CACHE_MODE` и перезапускает API; четыре фазы: + +| Фаза | Смысл | Ключевой результат | +|---|---|---| +| `off` | baseline: кэша нет | `reads=100 sql=132 stampede_sql=32` — 32 конкурентных холодных чтения = 32 SQL (stampede не ограничен) | +| `naive` | кэш БЕЗ инвалидации | `[PASS] naive: stale read OBSERVED` — прогретый кэш вернул страницу БЕЗ только что записанного сообщения (проблема показана) | +| `versioned` | защита: версия чата в ключе + single-flight | `[PASS] read-after-write OK`; `stampede_sql=1` (32 холодных чтения схлопнуты в один SQL); `reads=100 sql=0` (тёплые чтения из кэша) | +| `recovery` | `docker compose restart redis` | сессия валидна (источник истины Postgres), история читается, read-after-write OK, `sql_after_restart=1` (кэш перестроился) | + +**Механика защиты (для защиты):** +- Ключ кэша истории: `hist:v:::`, где N — счётчик версии чата в Redis. +- На каждый COMMIT записи (`CreateMessage`) выполняется `INCR chatver:`: старые ключи становятся «мёртвыми», следующее чтение строит ключ с новой версией → cache miss → свежий SELECT. Stale read исключён конструктивно, а не «удалением ключей». +- Single-flight: при конкурирующих miss одного ключа в SQL идёт ровно один запрос, остальные ждут его результат (защита от stampede без глобальной блокировки). +- Контрактное требование «кэш не возвращает устаревшую историю после успешной записи» выполнено в режиме `versioned` и проверено тестом. + +--- + +## Шаг 8. Финальная регрессия (всё зелёное одним прогоном) + +```powershell +python tests/smoke.py --base-url http://localhost:8080 # контракт +python student-tests/run_tests.py --base-url http://localhost:8080 # 46 проверок +python student-tests/failover_tests.py --base-url http://localhost:8080 +scripts\expiry.bat +scripts\cache_demo.bat +python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080 +``` + +Ожидаемые финальные строки: `PASS: lab2 public API scenario...`, `ALL STUDENT TESTS PASSED`, `ALL FAILOVER TESTS PASSED`, `EXPIRY CHECKS PASSED`, четыре `PHASE ... DONE`, `PASS: persistence preserved...`. + +--- + +## Артефакты демонстрации + +| Артефакт | Что доказывает | +|---|---| +| `docker compose logs api` (migration + shutdown/startup) | миграции с нуля, идемпотентность, graceful shutdown | +| `scripts/explain_plans.md` | индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на 30 002 сообщениях | +| `evidence/cache_track.md` + `evidence/phase_*.txt` | эксперимент трека 5: stale read, stampede, SQL-счётчики до/после, recovery | +| Вывод `tests/resilience.py` + `docker compose ps` до/после + `docker volume ls` | persistence hook действительно перезапустил API и оба хранилища, volumes сохранены | +| Вывод `student-tests/failover_tests.py` | деградация при Redis down; 503 при Postgres down; аноним не доверен | +| Вывод `student-tests/run_tests.py` | контрактные коды/заголовки, гонка регистрации, rollback, пагинация, logout | +| Вывод `scripts/expiry.bat` | expiry при коротком TTL | +| `git status` / `.gitignore` | `.env` и секреты не в Git | + +--- + +## Завершение стенда + +```powershell +# Безопасная остановка: volumes сохраняются +docker compose down + +# НАМЕРЕННОЕ удаление учебных данных: контейнеры И volumes (данные теряются) +docker compose down -v +``` diff --git a/src/cmd/server/main.go b/src/cmd/server/main.go new file mode 100644 index 00000000..30d8f352 --- /dev/null +++ b/src/cmd/server/main.go @@ -0,0 +1,136 @@ +package main + +import ( + "context" + "errors" + "log/slog" + "net/http" + "os" + "os/signal" + "sync/atomic" + "syscall" + "time" + + "mtusi-messenger/internal/api" + "mtusi-messenger/internal/store" + + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" +) + +func getenv(key, def string) string { + if v := os.Getenv(key); v != "" { + return v + } + return def +} + +func main() { + log := slog.New(slog.NewJSONHandler(os.Stdout, nil)) + + host := getenv("APP_HOST", "0.0.0.0") + port := getenv("APP_PORT", "8080") + addr := host + ":" + port + + databaseURL := getenv("DATABASE_URL", "postgres://messenger:messenger_password@localhost:5432/messenger?sslmode=disable") + redisURL := getenv("REDIS_URL", "redis://localhost:6379/0") + sessionStore := getenv("SESSION_STORE", "postgres") // postgres или redis + sessionTTL := getenv("SESSION_TTL_SECONDS", "3600") + cacheMode := getenv("CACHE_MODE", "versioned") // ← ИЗМЕНЕНИЕ: off | naive | versioned + + ctx := context.Background() + + // Подключение к PostgreSQL (пул соединений) + poolConfig, err := pgxpool.ParseConfig(databaseURL) + if err != nil { + log.Error("parse database URL", "error", err.Error()) + os.Exit(1) + } + poolConfig.MaxConns = 10 + poolConfig.MinConns = 2 + poolConfig.ConnConfig.ConnectTimeout = 5 * time.Second + poolConfig.MaxConnLifetime = 30 * time.Minute + poolConfig.MaxConnIdleTime = 5 * time.Minute + poolConfig.HealthCheckPeriod = 10 * time.Second + poolConfig.ConnConfig.RuntimeParams["statement_timeout"] = "15000" + + pool, err := pgxpool.NewWithConfig(ctx, poolConfig) + if err != nil { + log.Error("connect to postgres", "error", err.Error()) + os.Exit(1) + } + defer pool.Close() + + // Проверка соединения с БД + if err := pool.Ping(ctx); err != nil { + log.Error("ping postgres", "error", err.Error()) + os.Exit(1) + } + log.Info("postgres connected") + + // Запуск миграций + if err := store.RunMigrations(ctx, pool, log); err != nil { + log.Error("run migrations", "error", err.Error()) + os.Exit(1) + } + + // Подключение к Redis (опционально, для уровня 4) + var rdb *redis.Client + if sessionStore == "redis" { + opts, err := redis.ParseURL(redisURL) + if err != nil { + log.Error("parse redis URL", "error", err.Error()) + os.Exit(1) + } + rdb = redis.NewClient(opts) + if err := rdb.Ping(ctx).Err(); err != nil { + log.Warn("redis ping failed, falling back to postgres-only mode", "error", err.Error()) + rdb = nil // деградация: работаем без кэша + } else { + log.Info("redis connected") + defer rdb.Close() + } + } + + ready := &atomic.Bool{} + ready.Store(true) + + // ← ИЗМЕНЕНИЕ: передаём cacheMode пятым аргументом + st := store.New(pool, rdb, sessionTTL, cacheMode, log) + log.Info("store configured", "session_store", sessionStore, "cache_mode", cacheMode) + + srv := api.NewServer(st, log, ready) + httpSrv := &http.Server{ + Addr: addr, + Handler: srv.Handler(), + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 30 * time.Second, + IdleTimeout: 60 * time.Second, + } + + errCh := make(chan error, 1) + go func() { errCh <- httpSrv.ListenAndServe() }() + log.Info("server started", "addr", addr, "pid", os.Getpid()) + + stop := make(chan os.Signal, 1) + signal.Notify(stop, syscall.SIGTERM, syscall.SIGINT) + + select { + case err := <-errCh: + if err != nil && !errors.Is(err, http.ErrServerClosed) { + log.Error("server failed", "error", err.Error()) + os.Exit(1) + } + case sig := <-stop: + log.Info("shutdown signal received", "signal", sig.String()) + ready.Store(false) + ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second) + defer cancel() + if err := httpSrv.Shutdown(ctx); err != nil { + log.Warn("graceful shutdown exceeded budget, closing", "error", err.Error()) + _ = httpSrv.Close() + } + log.Info("server stopped cleanly") + } +} diff --git a/src/go.mod b/src/go.mod new file mode 100644 index 00000000..54fbcaba --- /dev/null +++ b/src/go.mod @@ -0,0 +1,20 @@ +module mtusi-messenger + +go 1.22 + +require ( + github.com/google/uuid v1.6.0 + github.com/jackc/pgx/v5 v5.5.5 + github.com/redis/go-redis/v9 v9.5.1 + golang.org/x/crypto v0.23.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect + github.com/jackc/puddle/v2 v2.2.1 // indirect + golang.org/x/sync v0.1.0 // indirect + golang.org/x/text v0.15.0 // indirect +) diff --git a/src/go.sum b/src/go.sum new file mode 100644 index 00000000..dd8d8aa2 --- /dev/null +++ b/src/go.sum @@ -0,0 +1,40 @@ +github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= +github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= +github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA= +github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk= +github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.5.5 h1:amBjrZVmksIdNjxGW/IiIMzxMKZFelXbUoPNb+8sjQw= +github.com/jackc/pgx/v5 v5.5.5/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A= +github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= +github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.5.1 h1:H1X4D3yHPaYrkL5X06Wh6xNVM/pX0Ft4RV0vMGvLBh8= +github.com/redis/go-redis/v9 v9.5.1/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI= +golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= +golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= +golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/src/internal/api/handlers.go b/src/internal/api/handlers.go new file mode 100644 index 00000000..4fabc5a2 --- /dev/null +++ b/src/internal/api/handlers.go @@ -0,0 +1,315 @@ +package api + +import ( + "errors" + "net/http" + + "mtusi-messenger/internal/apperr" + "mtusi-messenger/internal/model" + "mtusi-messenger/internal/store" +) + +// ───────────────────────────── health ───────────────────────────── + +func (s *Server) healthLive(w http.ResponseWriter, r *http.Request) { + writeJSON(w, r, http.StatusOK, model.Health{Status: "ok"}) +} + +// healthReady: готов = не закрываемся И БД доступна. БД мертва -> 503 unavailable: +// «ready» означает «могу безопасно обслуживать обязательный синхронный путь», +// а весь обязательный путь lab2 ходит в PostgreSQL. +func (s *Server) healthReady(w http.ResponseWriter, r *http.Request) { + id := requestID(r) + if !s.ready.Load() { + apperr.Write(w, id, apperr.Unavailable("service is shutting down")) + return + } + if err := s.store.Ping(r.Context()); err != nil { + apperr.Write(w, id, apperr.Unavailable("database unavailable")) + return + } + writeJSON(w, r, http.StatusOK, model.Health{Status: "ok"}) +} + +// ───────────────────────────── users ───────────────────────────── + +// usersRoute — POST /api/v1/users: публичная регистрация с паролем. +func (s *Server) usersRoute(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + methodNotAllowed(w, r) + return + } + id := requestID(r) + var req model.CreateUserReq + if aerr := decodeJSON(w, r, &req); aerr != nil { + apperr.Write(w, id, aerr) + return + } + if !usernameRe.MatchString(req.Username) { + apperr.Write(w, id, apperr.InvalidRequest("username must match ^[a-z0-9_]{3,32}$")) + return + } + if !validText(req.DisplayName, 100) { + apperr.Write(w, id, apperr.InvalidRequest("display_name must be 1..100 non-space code points")) + return + } + if !validPassword(req.Password) { // 12..128 code points, не только пробелы + apperr.Write(w, id, apperr.InvalidRequest("password must be 12..128 non-space code points")) + return + } + u, err := s.store.CreateUser(r.Context(), req.Username, req.DisplayName, req.Password) + if err != nil { + s.writeStoreErr(w, r, err) + return + } + writeJSON(w, r, http.StatusCreated, u) // пароль и hash НЕ попадают в ответ +} + +// me — текущий пользователь из сессии. +func (s *Server) me(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodGet { + methodNotAllowed(w, r) + return + } + writeJSON(w, r, http.StatusOK, currentUser(r)) +} + +// ───────────────────────────── sessions ───────────────────────────── + +// createSession — POST /api/v1/auth/sessions: Basic -> сессия с Bearer-токеном. +// Тела НЕТ (контракт): ничего не декодируем, credentials пришли из заголовка. +func (s *Server) createSession(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + methodNotAllowed(w, r) + return + } + id := requestID(r) + creds := currentCreds(r) + user, err := s.store.UserByCredentials(r.Context(), creds.Username, creds.Password) + if err != nil { + // Неизвестный user и неверный пароль -> ОДИНАКОВЫЙ 401 + Basic-заголовок: + // не помогаем перебору учёток. + w.Header().Set("WWW-Authenticate", wwwBasic) + apperr.Write(w, id, apperr.Unauthorized("invalid credentials")) + return + } + token, expiresAt, err := s.store.CreateSession(r.Context(), user.ID) + if err != nil { + apperr.Write(w, id, apperr.Internal("internal error")) + return + } + writeJSON(w, r, http.StatusCreated, model.SessionResponse{ + Token: token, + TokenType: "Bearer", + ExpiresAt: model.Timestamp{Time: expiresAt}, + User: *user, + }) +} + +// revokeSession — DELETE /api/v1/auth/sessions/current: отзыв токена. +func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodDelete { + methodNotAllowed(w, r) + return + } + if err := s.store.RevokeSession(r.Context(), currentToken(r)); err != nil { + apperr.Write(w, requestID(r), apperr.Unavailable("logout not confirmed, please retry")) + return + } + writeNoContent(w, r) +} + +// ───────────────────────────── chats ───────────────────────────── + +func (s *Server) chatsRoute(w http.ResponseWriter, r *http.Request) { + switch r.Method { + case http.MethodPost: + s.createChat(w, r) + case http.MethodGet: + s.listChats(w, r) + default: + methodNotAllowed(w, r) + } +} + +func (s *Server) createChat(w http.ResponseWriter, r *http.Request) { + id := requestID(r) + var req model.CreateChatReq + if aerr := decodeJSON(w, r, &req); aerr != nil { + apperr.Write(w, id, aerr) + return + } + if !validText(req.Title, 100) { + apperr.Write(w, id, apperr.InvalidRequest("title must be 1..100 non-space code points")) + return + } + if len(req.MemberIDs) < 1 || len(req.MemberIDs) > 100 { + apperr.Write(w, id, apperr.InvalidRequest("member_ids must contain 1..100 items")) + return + } + seen := make(map[string]bool, len(req.MemberIDs)) + for _, raw := range req.MemberIDs { + uid, err := parseUUID(raw) + if err != nil { + apperr.Write(w, id, apperr.InvalidRequest("member_ids must be UUID strings")) + return + } + if seen[uid] { + apperr.Write(w, id, apperr.InvalidRequest("duplicate member_id")) + return + } + seen[uid] = true + } + caller := currentUser(r) + if !seen[caller.ID] { // вызывающий обязан быть в списке (README) + apperr.Write(w, id, apperr.InvalidRequest("creator must be included in member_ids")) + return + } + // Составная операция в одной транзакции; неизвестные участники -> ErrBadMembers -> 400. + chat, err := s.store.CreateChat(r.Context(), req.Title, req.MemberIDs, caller.ID) + if err != nil { + s.writeStoreErr(w, r, err) + return + } + writeJSON(w, r, http.StatusCreated, chat) +} + +func (s *Server) listChats(w http.ResponseWriter, r *http.Request) { + id := requestID(r) + caller := currentUser(r) + limit, cur, aerr := pagingParams(r, caller.ID) + if aerr != nil { + apperr.Write(w, id, aerr) + return + } + items, more, err := s.store.ListChats(r.Context(), caller.ID, limit, cur) + if err != nil { + s.writeStoreErr(w, r, err) + return + } + page := model.Page[*model.Chat]{Items: items} + if more && len(items) > 0 { + last := items[len(items)-1] + encoded := store.EncodeCursor(store.Cursor{Scope: caller.ID, TS: last.CreatedAt.Time, ID: last.ID}) + page.NextCursor = &encoded + } + writeJSON(w, r, http.StatusOK, page) +} + +func (s *Server) chatRoute(w http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodGet { + methodNotAllowed(w, r) + return + } + id := requestID(r) + chatID, err := parseUUID(r.PathValue("chat_id")) + if err != nil { + apperr.Write(w, id, apperr.InvalidRequest("chat_id must be a UUID")) + return + } + chat, err := s.store.ChatForUser(r.Context(), chatID, currentUser(r).ID) + if err != nil { + // БЫЛО: apperr.NotFound напрямую. СТАЛО: writeStoreErr, чтобы БД down → 503, а не 404. + s.writeStoreErr(w, r, err) + return + } + writeJSON(w, r, http.StatusOK, chat) +} + +// ───────────────────────────── messages ───────────────────────────── + +func (s *Server) messagesRoute(w http.ResponseWriter, r *http.Request) { + switch r.Method { + case http.MethodPost: + s.createMessage(w, r) + case http.MethodGet: + s.listMessages(w, r) + default: + methodNotAllowed(w, r) + } +} + +func (s *Server) createMessage(w http.ResponseWriter, r *http.Request) { + id := requestID(r) + chatID, err := parseUUID(r.PathValue("chat_id")) + if err != nil { + apperr.Write(w, id, apperr.InvalidRequest("chat_id must be a UUID")) + return + } + chat, err := s.store.ChatForUser(r.Context(), chatID, currentUser(r).ID) + if err != nil { + // БЫЛО: apperr.NotFound напрямую. СТАЛО: writeStoreErr (БД down → 503). + s.writeStoreErr(w, r, err) + return + } + var req model.CreateMessageReq + if aerr := decodeJSON(w, r, &req); aerr != nil { + apperr.Write(w, id, aerr) + return + } + if !validText(req.Text, 4000) { + apperr.Write(w, id, apperr.InvalidRequest("text must be 1..4000 non-space code points")) + return + } + msg, err := s.store.CreateMessage(r.Context(), chat.ID, currentUser(r).ID, req.Text) + if err != nil { + // БЫЛО: apperr.NotFound напрямую. СТАЛО: writeStoreErr (БД down → 503). + s.writeStoreErr(w, r, err) + return + } + writeJSON(w, r, http.StatusCreated, msg) +} + +func (s *Server) listMessages(w http.ResponseWriter, r *http.Request) { + id := requestID(r) + chatID, err := parseUUID(r.PathValue("chat_id")) + if err != nil { + apperr.Write(w, id, apperr.InvalidRequest("chat_id must be a UUID")) + return + } + chat, err := s.store.ChatForUser(r.Context(), chatID, currentUser(r).ID) + if err != nil { + // БЫЛО: apperr.NotFound напрямую. СТАЛО: writeStoreErr (БД down → 503). + s.writeStoreErr(w, r, err) + return + } + limit, cur, aerr := pagingParams(r, chat.ID) + if aerr != nil { + apperr.Write(w, id, aerr) + return + } + items, more, err := s.store.ListMessages(r.Context(), chat.ID, limit, cur) + if err != nil { + // БЫЛО: apperr.Internal напрямую. СТАЛО: writeStoreErr (БД down → 503). + s.writeStoreErr(w, r, err) + return + } + page := model.Page[*model.Message]{Items: items} + if more && len(items) > 0 { + last := items[len(items)-1] + encoded := store.EncodeCursor(store.Cursor{Scope: chat.ID, TS: last.CreatedAt.Time, ID: last.ID}) + page.NextCursor = &encoded + } + writeJSON(w, r, http.StatusOK, page) +} + +func (s *Server) notFound(w http.ResponseWriter, r *http.Request) { + apperr.Write(w, requestID(r), apperr.NotFound("route not found")) +} + +// writeStoreErr — единый перевод флажков store в статусы контракта. +func (s *Server) writeStoreErr(w http.ResponseWriter, r *http.Request, err error) { + id := requestID(r) + switch { + case errors.Is(err, store.ErrNotFound): + apperr.Write(w, id, apperr.NotFound("chat not found or not accessible")) + case errors.Is(err, store.ErrBadMembers): + apperr.Write(w, id, apperr.InvalidRequest("unknown member_id")) + case errors.Is(err, store.ErrUsernameTaken): + apperr.Write(w, id, apperr.Conflict("username is already taken")) + case store.IsUnavailable(err): + apperr.Write(w, id, apperr.Unavailable("database unavailable")) + default: + apperr.Write(w, id, apperr.Internal("internal error")) + } +} diff --git a/src/internal/api/helpers.go b/src/internal/api/helpers.go new file mode 100644 index 00000000..7fa646a3 --- /dev/null +++ b/src/internal/api/helpers.go @@ -0,0 +1,151 @@ +// package api, helpers.go — пограничный контроль входа (перенос из lab1 + разбор Authorization). +package api + +import ( + "encoding/base64" + "encoding/json" + "errors" + "mime" + "net/http" + "regexp" + "strconv" + "strings" + "unicode/utf8" + + "github.com/google/uuid" + + "mtusi-messenger/internal/apperr" + "mtusi-messenger/internal/store" +) + +const maxBodyBytes = 1 << 20 + +var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +// parseUUID — канонический UUID или ошибка (из lab1). +func parseUUID(s string) (string, error) { + u, err := uuid.Parse(s) + if err != nil || u.String() != s { + return "", errors.New("invalid uuid") + } + return u.String(), nil +} + +func runeLen(s string) int { return utf8.RuneCountInString(s) } + +// validText — обязательная строка 1..max code points, не только пробелы (из lab1). +func validText(s string, max int) bool { + n := runeLen(s) + return n >= 1 && n <= max && strings.TrimSpace(s) != "" +} + +// validPassword — контракт lab2: 12–128 code points, UTF-8, двоеточие допустимо. +// Общее правило README «не только пробельные» тоже применяем. +func validPassword(s string) bool { + n := runeLen(s) + return n >= 12 && n <= 128 && strings.TrimSpace(s) != "" +} + +// loginCreds — распарсенные Basic-credentials. +type loginCreds struct { + Username string + Password string +} + +// parseBasicHeader — «Basic ». +// КЛЮЧЕВАЯ ДЕТАЛЬ: пароль может содержать двоеточие, поэтому режем по ПЕРВОЙ «:» +// (strings.Cut), а не по всем: "alice:pa:ss:word" -> username="alice", password="pa:ss:word". +func parseBasicHeader(r *http.Request) (loginCreds, bool) { + h := r.Header.Get("Authorization") + const prefix = "Basic " + if !strings.HasPrefix(h, prefix) { + return loginCreds{}, false + } + raw, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(h, prefix)) + if err != nil { + return loginCreds{}, false + } + u, p, found := strings.Cut(string(raw), ":") + if !found { + return loginCreds{}, false + } + return loginCreds{Username: u, Password: p}, true +} + +// parseBearerHeader — «Bearer »; пустой токен не принимаем. +func parseBearerHeader(r *http.Request) (string, bool) { + h := r.Header.Get("Authorization") + const prefix = "Bearer " + if !strings.HasPrefix(h, prefix) { + return "", false + } + t := strings.TrimPrefix(h, prefix) + if t == "" { + return "", false + } + return t, true +} + +// decodeJSON — конвейер 415 -> 413 -> 400 (из lab1, без изменений). +func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) *apperr.AppError { + media, _, _ := mime.ParseMediaType(r.Header.Get("Content-Type")) + if media != "application/json" { + return apperr.UnsupportedMedia("Content-Type must be application/json") + } + r.Body = http.MaxBytesReader(w, r.Body, maxBodyBytes) + dec := json.NewDecoder(r.Body) + dec.DisallowUnknownFields() + if err := dec.Decode(dst); err != nil { + var maxErr *http.MaxBytesError + if errors.As(err, &maxErr) { + return apperr.PayloadTooLarge("request body too large") + } + return apperr.InvalidRequest("malformed JSON body") + } + if dec.More() { + return apperr.InvalidRequest("multiple JSON documents in body") + } + return nil +} + +// pagingParams — limit 1..100 (default 50) + курсор с проверкой scope (из lab1). +func pagingParams(r *http.Request, scope string) (int, *store.Cursor, *apperr.AppError) { + limit := 50 + if v := r.URL.Query().Get("limit"); v != "" { + n, err := strconv.Atoi(v) + if err != nil || n < 1 || n > 100 { + return 0, nil, apperr.InvalidRequest("limit must be an integer in 1..100") + } + limit = n + } + var cur *store.Cursor + if v := r.URL.Query().Get("cursor"); v != "" { + c, err := store.DecodeCursor(v) + if err != nil { + return 0, nil, apperr.InvalidRequest("invalid cursor") + } + if c.Scope != scope { + return 0, nil, apperr.InvalidRequest("cursor does not belong to this resource") + } + cur = &c + } + return limit, cur, nil +} + +// writeJSON — единая точка успешного ответа (из lab1). +func writeJSON(w http.ResponseWriter, r *http.Request, status int, payload any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("X-Request-Id", requestID(r)) + w.WriteHeader(status) + _ = json.NewEncoder(w).Encode(payload) +} + +// writeNoContent — 204 без тела (logout). Тела нет, но заголовки контракта остаются. +func writeNoContent(w http.ResponseWriter, r *http.Request) { + w.Header().Set("X-Request-Id", requestID(r)) + w.WriteHeader(http.StatusNoContent) +} + +func methodNotAllowed(w http.ResponseWriter, r *http.Request) { + apperr.Write(w, requestID(r), apperr.New(http.StatusMethodNotAllowed, apperr.CodeInvalidRequest, "method not allowed")) +} diff --git a/src/internal/api/middleware.go b/src/internal/api/middleware.go new file mode 100644 index 00000000..734b31be --- /dev/null +++ b/src/internal/api/middleware.go @@ -0,0 +1,146 @@ +// package api, middleware.go — охранники + новая аутентификация lab2. +package api + +import ( + "context" + "log/slog" + "mtusi-messenger/internal/store" + "net/http" + "strings" + "time" + + "github.com/google/uuid" + + "mtusi-messenger/internal/apperr" + "mtusi-messenger/internal/model" +) + +type ctxKey int + +const ( + ctxRequestID ctxKey = iota + ctxUser // текущий пользователь (из сессии) + ctxToken // сам токен (нужен logout'у) + ctxCreds // распарсенные Basic-credentials (нужны createSession) +) + +// Значения WWW-Authenticate из контракта — одни и те же во всех 401 соответствующего типа. +const ( + wwwBearer = `Bearer realm="messenger"` + wwwBasic = `Basic realm="messenger", charset="UTF-8"` +) + +// ─────────── Охранник 1: номерок (из lab1) ─────────── +func requestIDMiddleware(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + id := r.Header.Get("X-Request-Id") + if id == "" { + id = uuid.NewString() + } + w.Header().Set("X-Request-Id", id) + next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), ctxRequestID, id))) + }) +} + +func requestID(r *http.Request) string { + if id, ok := r.Context().Value(ctxRequestID).(string); ok && id != "" { + return id + } + return "unknown" +} + +// ─────────── Охранник 2: журнал без тел (из lab1) ─────────── +type statusWriter struct { + http.ResponseWriter + status int +} + +func (s *statusWriter) WriteHeader(code int) { + s.status = code + s.ResponseWriter.WriteHeader(code) +} + +func loggingMiddleware(log *slog.Logger, next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + sw := &statusWriter{ResponseWriter: w, status: http.StatusOK} + next.ServeHTTP(sw, r) + log.Info("http", + "method", r.Method, + "path", r.URL.Path, + "status", sw.status, + "dur_ms", time.Since(start).Milliseconds(), + "request_id", requestID(r), + ) + }) +} + +// ─────────── Охранник 3: выключатель паник (из lab1) ─────────── +func recoverMiddleware(log *slog.Logger, next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + defer func() { + if rec := recover(); rec != nil { + log.Error("panic recovered", "path", r.URL.Path, "request_id", requestID(r)) + apperr.Write(w, requestID(r), apperr.Internal("internal error")) + } + }() + next.ServeHTTP(w, r) + }) +} + +// ─────────── Пропускной пункт lab2: Bearer ─────────── +// Правила контракта, зашитые сюда: +// 1. Нет токена / не Bearer / токен неизвестен|истёк|отозван -> 401 + WWW-Authenticate: Bearer. +// 2. Basic на бизнес-endpoint -> 401 (Basic живёт только на /auth/sessions). +// 3. X-User-Id ИГНОРИРУЕТСЯ: с lab2 он не даёт доступ вообще (мы его даже не читаем). +func (s *Server) auth(next http.HandlerFunc) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + id := requestID(r) + h := r.Header.Get("Authorization") + if strings.HasPrefix(h, "Basic ") { // чужая схема на защищённом пути + w.Header().Set("WWW-Authenticate", wwwBearer) + apperr.Write(w, id, apperr.Unauthorized("Bearer token required")) + return + } + token, ok := parseBearerHeader(r) + if !ok { + w.Header().Set("WWW-Authenticate", wwwBearer) + apperr.Write(w, id, apperr.Unauthorized("Bearer token required")) + return + } + user, err := s.store.SessionUser(r.Context(), token) + if err != nil { + if store.IsUnavailable(err) { // БД мертва -> 503, а не 401 и не 200 + apperr.Write(w, id, apperr.Unavailable("database unavailable")) + return + } + w.Header().Set("WWW-Authenticate", wwwBearer) + apperr.Write(w, id, apperr.Unauthorized("valid Bearer token required")) + return + } + ctx := context.WithValue(r.Context(), ctxUser, user) + ctx = context.WithValue(ctx, ctxToken, token) // токен едет дальше: его заберёт logout + next.ServeHTTP(w, r.WithContext(ctx)) + } +} + +// ─────────── Входная дверь: только Basic ─────────── +// Проверяет ФОРМАТ заголовка; сверку пароля с KDF-хэшем делает хендлер (нужна БД). +// Любой провал формата -> 401 + WWW-Authenticate: Basic (тот же ответ, что и +// неверные credentials: существование учётки не раскрывается). +func (s *Server) basicOnly(next http.HandlerFunc) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + id := requestID(r) + creds, ok := parseBasicHeader(r) + if !ok { + w.Header().Set("WWW-Authenticate", wwwBasic) + apperr.Write(w, id, apperr.Unauthorized("Basic credentials required")) + return + } + next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), ctxCreds, creds))) + } +} + +func currentUser(r *http.Request) *model.User { return r.Context().Value(ctxUser).(*model.User) } +func currentToken(r *http.Request) string { return r.Context().Value(ctxToken).(string) } +func currentCreds(r *http.Request) loginCreds { return r.Context().Value(ctxCreds).(loginCreds) } diff --git a/src/internal/api/router.go b/src/internal/api/router.go new file mode 100644 index 00000000..b5c9eb29 --- /dev/null +++ b/src/internal/api/router.go @@ -0,0 +1,43 @@ +// package api, router.go — сборка цепочки; карта публично/защищено из OpenAPI lab2. +package api + +import ( + "log/slog" + "net/http" + "sync/atomic" + + "mtusi-messenger/internal/store" +) + +type Server struct { + store *store.Store + log *slog.Logger + ready *atomic.Bool +} + +func NewServer(st *store.Store, log *slog.Logger, ready *atomic.Bool) *Server { + return &Server{store: st, log: log, ready: ready} +} + +func (s *Server) Handler() http.Handler { + mux := http.NewServeMux() + // Публичные (security: [] в OpenAPI): + mux.HandleFunc("/health/live", s.healthLive) + mux.HandleFunc("/health/ready", s.healthReady) + mux.HandleFunc("/api/v1/users", s.usersRoute) + // Вход — ТОЛЬКО Basic: + mux.HandleFunc("/api/v1/auth/sessions", s.basicOnly(s.createSession)) + // Всё остальное — только Bearer: + mux.HandleFunc("/api/v1/auth/sessions/current", s.auth(s.revokeSession)) + mux.HandleFunc("/api/v1/users/me", s.auth(s.me)) + mux.HandleFunc("/api/v1/chats", s.auth(s.chatsRoute)) + mux.HandleFunc("/api/v1/chats/{chat_id}", s.auth(s.chatRoute)) + mux.HandleFunc("/api/v1/chats/{chat_id}/messages", s.auth(s.messagesRoute)) + mux.HandleFunc("/", s.notFound) + + var h http.Handler = mux + h = recoverMiddleware(s.log, h) + h = loggingMiddleware(s.log, h) + h = requestIDMiddleware(h) + return h +} diff --git a/src/internal/apperr/errors.go b/src/internal/apperr/errors.go new file mode 100644 index 00000000..edb789d1 --- /dev/null +++ b/src/internal/apperr/errors.go @@ -0,0 +1,65 @@ +package apperr + +import ( + "encoding/json" + "net/http" +) + +type Code string + +const ( + CodeInvalidRequest Code = "invalid_request" + CodeUnauthorized Code = "unauthorized" + CodeNotFound Code = "not_found" + CodeConflict Code = "conflict" + CodePayloadTooLarge Code = "payload_too_large" + CodeUnsupportedMedia Code = "unsupported_media_type" + CodeRateLimited Code = "rate_limited" + CodeUnavailable Code = "unavailable" + CodeInternal Code = "internal_error" +) + +type Body struct { + Code Code `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} + +type Envelope struct { + Error Body `json:"error"` +} + +type AppError struct { + Status int + Code Code + Msg string +} + +func (e *AppError) Error() string { return e.Msg } + +func New(status int, code Code, msg string) *AppError { + return &AppError{Status: status, Code: code, Msg: msg} +} + +func InvalidRequest(msg string) *AppError { return New(http.StatusBadRequest, CodeInvalidRequest, msg) } +func Unauthorized(msg string) *AppError { return New(http.StatusUnauthorized, CodeUnauthorized, msg) } +func NotFound(msg string) *AppError { return New(http.StatusNotFound, CodeNotFound, msg) } +func Conflict(msg string) *AppError { return New(http.StatusConflict, CodeConflict, msg) } +func PayloadTooLarge(msg string) *AppError { + return New(http.StatusRequestEntityTooLarge, CodePayloadTooLarge, msg) +} +func UnsupportedMedia(msg string) *AppError { + return New(http.StatusUnsupportedMediaType, CodeUnsupportedMedia, msg) +} +func Unavailable(msg string) *AppError { + return New(http.StatusServiceUnavailable, CodeUnavailable, msg) +} +func Internal(msg string) *AppError { return New(http.StatusInternalServerError, CodeInternal, msg) } + +// Write отдаёт ошибку в формате контракта: {"error":{"code","message","request_id"}}. +func Write(w http.ResponseWriter, requestID string, err *AppError) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.Header().Set("X-Request-Id", requestID) + w.WriteHeader(err.Status) + _ = json.NewEncoder(w).Encode(Envelope{Error: Body{Code: err.Code, Message: err.Msg, RequestID: requestID}}) +} diff --git a/src/internal/model/models.go b/src/internal/model/models.go new file mode 100644 index 00000000..9d5842c3 --- /dev/null +++ b/src/internal/model/models.go @@ -0,0 +1,89 @@ +package model + +import ( + "strconv" + "time" +) + +// Timestamp — детерминированная сериализация времени (ровно 3 знака миллисекунд). +// Из lab1, без изменений. +type Timestamp struct{ time.Time } + +func (t Timestamp) MarshalJSON() ([]byte, error) { + s := t.UTC().Format("2006-01-02T15:04:05.000Z") + return strconv.AppendQuote(nil, s), nil +} + +func NowTS() Timestamp { return Timestamp{Time: time.Now().UTC().Truncate(time.Millisecond)} } + +// User — ответ API: пароль и его hash НЕ включены (контракт). +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt Timestamp `json:"created_at"` +} + +// CreateUserReq — вход регистрации: username + display_name + password. +// Password только на входе, в User не попадает. +type CreateUserReq struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` +} + +// LoginRequest — вход в систему через Basic Auth (парсится из заголовка Authorization). +type LoginRequest struct { + Username string + Password string +} + +// Session — внутренняя модель сессии (не отдаётся клиенту). +type Session struct { + TokenHash []byte // SHA-256 от opaque-токена + UserID string + ExpiresAt time.Time + CreatedAt time.Time +} + +// SessionResponse — ответ POST /auth/sessions (то, что отдаём клиенту). +type SessionResponse struct { + Token string `json:"token"` + TokenType string `json:"token_type"` // всегда "Bearer" + ExpiresAt Timestamp `json:"expires_at"` + User User `json:"user"` +} + +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt Timestamp `json:"created_at"` +} + +type CreateChatReq struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` +} + +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt Timestamp `json:"created_at"` +} + +type CreateMessageReq struct { + Text string `json:"text"` +} + +// Page — дженерик-страница (из lab1). +type Page[T any] struct { + Items []T `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +type Health struct { + Status string `json:"status"` +} diff --git a/src/internal/store/cache.go b/src/internal/store/cache.go new file mode 100644 index 00000000..fa823663 --- /dev/null +++ b/src/internal/store/cache.go @@ -0,0 +1,223 @@ +package store + +import ( + "context" + "crypto/sha256" + "encoding/base64" + "encoding/hex" + "encoding/json" + "errors" + "fmt" + "strings" + "sync" + "time" + + "github.com/redis/go-redis/v9" + + "mtusi-messenger/internal/model" +) + +// redisTimeout — максимальное время на одну Redis-операцию. +// При недоступном Redis клиент быстро возвращает ошибку, и мы деградируем +// в SQL, а не блокируем запрос (требование уровня 4 про потерю сервиса). +const redisTimeout = 300 * time.Millisecond + +// ─────────────── Кэш сессий (уровень 4) ─────────────── + +func sessKey(hash [sha256.Size]byte) string { return "sess:" + hex.EncodeToString(hash[:]) } + +// cacheSessionPut: TTL кэша = остаток срока сессии (политика expiry согласована +// с источником истины); при ошибке Redis — только warn, запрос живёт через SQL. +func (s *Store) cacheSessionPut(ctx context.Context, hash [sha256.Size]byte, userID string, expiresAt time.Time) { + if s.rdb == nil { + return + } + ttl := time.Until(expiresAt) + if ttl <= 0 { + return + } + val := userID + "|" + expiresAt.Format(time.RFC3339Nano) + rctx, cancel := context.WithTimeout(ctx, redisTimeout) + defer cancel() + if err := s.rdb.Set(rctx, sessKey(hash), val, ttl).Err(); err != nil { + s.log.Warn("redis set failed, degrading to postgres", "error", err.Error()) + } +} + +// cacheSessionGet: miss (redis.Nil) — норма; ошибка/таймаут Redis — деградация; +// истёкшее значение в кэше не доверяем (двойная страховка помимо TTL). +func (s *Store) cacheSessionGet(ctx context.Context, hash [sha256.Size]byte) (string, bool) { + if s.rdb == nil { + return "", false + } + rctx, cancel := context.WithTimeout(ctx, redisTimeout) + defer cancel() + val, err := s.rdb.Get(rctx, sessKey(hash)).Result() + if errors.Is(err, redis.Nil) { + return "", false + } + if err != nil { + s.log.Warn("redis get failed, degrading to postgres", "error", err.Error()) + return "", false + } + parts := strings.SplitN(val, "|", 2) + if len(parts) != 2 { + return "", false + } + exp, err := time.Parse(time.RFC3339Nano, parts[1]) + if err != nil || time.Now().UTC().After(exp) { + return "", false + } + return parts[0], true +} + +func (s *Store) cacheSessionDel(ctx context.Context, hash [sha256.Size]byte) error { + if s.rdb == nil { + return nil + } + rctx, cancel := context.WithTimeout(ctx, redisTimeout) + defer cancel() + return s.rdb.Del(rctx, sessKey(hash)).Err() +} + +// ─────────────── Версия чата (инвалидация кэша истории, трек 5) ─────────────── + +func chatVerKey(chatID string) string { return "chatver:" + chatID } + +func (s *Store) bumpChatVersion(ctx context.Context, chatID string) { + if s.rdb == nil { + return + } + var err error + for attempt := 1; attempt <= 3; attempt++ { + rctx, cancel := context.WithTimeout(ctx, redisTimeout) + err = s.rdb.Incr(rctx, chatVerKey(chatID)).Err() + cancel() + if err == nil { + return + } + s.log.Warn("redis incr failed, retrying", "attempt", attempt, "error", err.Error()) + time.Sleep(50 * time.Millisecond) + } + s.log.Warn("redis incr failed after retries; history cache bounded stale until TTL", "error", err.Error()) +} + +// ChatVersion: 0 при отсутствии Redis/ключа — кэш истории тогда не используется, +// корректность не страдает. +func (s *Store) ChatVersion(ctx context.Context, chatID string) int64 { + if s.rdb == nil { + return 0 + } + rctx, cancel := context.WithTimeout(ctx, redisTimeout) + defer cancel() + v, err := s.rdb.Get(rctx, chatVerKey(chatID)).Int64() + if err != nil { + return 0 + } + return v +} + +// ─────────────── Кэш истории (трек 5) ─────────────── + +// HistoryCacheKey — ключ страницы истории: версия чата + параметры запроса. +// Версия в ключе — это и есть защита от stale read. +func HistoryCacheKey(chatID string, version int64, cursorJSON string, limit int) string { + return fmt.Sprintf("hist:v%d:%s:%s:%d", version, chatID, cursorJSON, limit) +} + +// CacheHistoryPut — положить страницу в кэш. TTL 60 c: кэш для горячего чтения, +// не долгосрочное хранилище; источник истины остаётся Postgres. +func (s *Store) CacheHistoryPut(ctx context.Context, key string, messages []*model.Message, hasMore bool) { + if s.rdb == nil { + return + } + data := map[string]any{ + "items": messages, + "has_more": hasMore, + "cached_at": time.Now().UTC().Format(time.RFC3339Nano), + } + b, err := json.Marshal(data) + if err != nil { + return + } + rctx, cancel := context.WithTimeout(ctx, redisTimeout) + defer cancel() + if err := s.rdb.Set(rctx, key, b, 60*time.Second).Err(); err != nil { + s.log.Warn("redis history set failed", "error", err.Error()) + } +} + +// CacheHistoryGet — достать страницу из кэша: (items, hasMore, ok). +// ok=false означает miss или ошибку Redis — тогда идём в SQL. +func (s *Store) CacheHistoryGet(ctx context.Context, key string) ([]*model.Message, bool, bool) { + if s.rdb == nil { + return nil, false, false + } + rctx, cancel := context.WithTimeout(ctx, redisTimeout) + defer cancel() + val, err := s.rdb.Get(rctx, key).Result() + if err != nil { + return nil, false, false + } + var data struct { + Items []*model.Message `json:"items"` + HasMore bool `json:"has_more"` + } + if err := json.Unmarshal([]byte(val), &data); err != nil { + return nil, false, false + } + return data.Items, data.HasMore, true +} + +// ─────────────── Single-flight (защита от cache stampede) ─────────────── +// При конкурирующих холодных чтениях одного ключа только один поток выполняет +// fn; остальные ждут его результат. Без этого N конкурентных miss дали бы N +// SQL-запросов («лавиной») — это и есть cache stampede. + +type SingleFlight struct { + mu sync.Mutex + m map[string]*call +} + +type call struct { + wg sync.WaitGroup + val any + err error +} + +func NewSingleFlight() *SingleFlight { + return &SingleFlight{m: make(map[string]*call)} +} + +// Do выполняет fn только если нет активного вызова с тем же key; иначе ждёт +// готовый результат того вызова. +func (sf *SingleFlight) Do(key string, fn func() (any, error)) (any, error) { + sf.mu.Lock() + if c, ok := sf.m[key]; ok { + sf.mu.Unlock() + c.wg.Wait() + return c.val, c.err + } + c := new(call) + c.wg.Add(1) + sf.m[key] = c + sf.mu.Unlock() + + c.val, c.err = fn() + c.wg.Done() + + sf.mu.Lock() + delete(sf.m, key) + sf.mu.Unlock() + + return c.val, c.err +} + +// EncodeCursorJSON — компактное представление курсора для ключа кэша. +func EncodeCursorJSON(c *Cursor) string { + if c == nil { + return "null" + } + b, _ := json.Marshal(c) + return base64.RawURLEncoding.EncodeToString(b) +} diff --git a/src/internal/store/migrations.go b/src/internal/store/migrations.go new file mode 100644 index 00000000..37550ffa --- /dev/null +++ b/src/internal/store/migrations.go @@ -0,0 +1,47 @@ +package store + +import ( + "context" + "embed" + "fmt" + "io/fs" + "log/slog" + "path/filepath" + "sort" + "strings" + + "github.com/jackc/pgx/v5/pgxpool" +) + +//go:embed migrations/*.sql +var migrationsFS embed.FS + +// RunMigrations запускает все миграции из папки migrations/ по алфавиту. +// Идемпотентно: IF NOT EXISTS в SQL защищает от дублей. +func RunMigrations(ctx context.Context, pool *pgxpool.Pool, log *slog.Logger) error { + entries, err := fs.ReadDir(migrationsFS, "migrations") + if err != nil { + return fmt.Errorf("read migrations dir: %w", err) + } + + // Сортируем по имени файла (0001_init.sql, 0002_..., ...) + var files []string + for _, e := range entries { + if !e.IsDir() && strings.HasSuffix(e.Name(), ".sql") { + files = append(files, e.Name()) + } + } + sort.Strings(files) + + for _, name := range files { + sql, err := fs.ReadFile(migrationsFS, filepath.Join("migrations", name)) + if err != nil { + return fmt.Errorf("read migration %s: %w", name, err) + } + log.Info("running migration", "file", name) + if _, err := pool.Exec(ctx, string(sql)); err != nil { + return fmt.Errorf("exec migration %s: %w", name, err) + } + } + return nil +} diff --git a/src/internal/store/migrations/0001_init.sql b/src/internal/store/migrations/0001_init.sql new file mode 100644 index 00000000..2bcbe891 --- /dev/null +++ b/src/internal/store/migrations/0001_init.sql @@ -0,0 +1,48 @@ +-- Все операции идемпотентны (IF NOT EXISTS) + +-- Пользователи +CREATE TABLE IF NOT EXISTS users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT users_username_re CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100) + ); +CREATE UNIQUE INDEX IF NOT EXISTS users_username_key ON users (username); + +-- Чаты +CREATE TABLE IF NOT EXISTS chats ( + id uuid PRIMARY KEY, + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL DEFAULT now() + ); + +-- Участники чатов +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) + ); +CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id, chat_id); + +-- Сообщения +CREATE TABLE IF NOT EXISTS messages ( + id uuid NOT NULL, + chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users(id), + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (chat_id, id) + ); +CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id); + +-- Сессии (источник истины) +CREATE TABLE IF NOT EXISTS sessions ( + token_hash bytea PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at timestamptz NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() + ); +CREATE INDEX IF NOT EXISTS sessions_expires_idx ON sessions (expires_at); \ No newline at end of file diff --git a/src/internal/store/postgres.go b/src/internal/store/postgres.go new file mode 100644 index 00000000..d44b7b3d --- /dev/null +++ b/src/internal/store/postgres.go @@ -0,0 +1,584 @@ +// Package store — слой доступа к данным lab2. +// PostgreSQL = источник истины (пользователи, чаты, участники, сообщения, сессии). +// Redis = опциональный кэш (сессии + история в треке 5): при его потере +// деградируем в SQL, а не отказываем (требование уровня 4). +// +// ВСЕ запросы параметризованы ($1, $2, ...): значения никогда не конкатенируются +// в текст SQL — это защита от SQL-инъекций (пункт уровня 4). +package store + +import ( + "context" + "crypto/rand" + "crypto/sha256" + "crypto/subtle" + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "log/slog" + "net" + "sort" + "strconv" + "strings" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + "github.com/redis/go-redis/v9" + "golang.org/x/crypto/scrypt" + + "mtusi-messenger/internal/model" +) + +// Sentinel-ошибки: store НЕ ЗНАЕТ про HTTP; хендлеры маппят флажки в статусы. +var ( + ErrNotFound = errors.New("not found") // объекта нет ИЛИ он чужой + ErrUsernameTaken = errors.New("username taken") // unique-ограничение + ErrInvalidCursor = errors.New("invalid cursor") // битая/чужая закладка + ErrInvalidLogin = errors.New("invalid credentials") // неверный пароль ИЛИ неизвестный user (намеренно одно!) + ErrBadMembers = errors.New("invalid member_ids") // неизвестный участник / вызывающий не в списке +) + +// Store — доступ к PostgreSQL (+ опциональный Redis). +type Store struct { + pool *pgxpool.Pool // ограниченный пул соединений (уровень 4) + rdb *redis.Client // nil = режим деградации без кэша + sessionTTL time.Duration // из SESSION_TTL_SECONDS + cacheMode string // "off" | "naive" | "versioned"; дефолт versioned (трек 5) + log *slog.Logger + sf *SingleFlight // stampede-защита кэша истории (трек 5) +} + +// New собирает Store. sessionTTLSeconds и cacheMode приходят строками из env. +func New(pool *pgxpool.Pool, rdb *redis.Client, sessionTTLSeconds, cacheMode string, log *slog.Logger) *Store { + ttl := 3600 + if v, err := strconv.Atoi(sessionTTLSeconds); err == nil && v > 0 { + ttl = v + } + if cacheMode == "" { + cacheMode = "versioned" + } + return &Store{ + pool: pool, + rdb: rdb, + sessionTTL: time.Duration(ttl) * time.Second, + cacheMode: cacheMode, + log: log, + sf: NewSingleFlight(), + } +} + +// Ping — живость БД; используется в /health/ready: БД мертва => 503. +func (s *Store) Ping(ctx context.Context) error { return s.pool.Ping(ctx) } + +// ─────────────── Курсор и пагинация (перенесено из lab1 без изменений) ─────────────── + +type Cursor struct { + Scope string `json:"s"` // чей ресурс: id чата или id пользователя + TS time.Time `json:"t"` // время записи-закладки + ID string `json:"i"` // id записи-закладки +} + +func EncodeCursor(c Cursor) string { + b, _ := json.Marshal(c) + return base64.RawURLEncoding.EncodeToString(b) +} + +func DecodeCursor(s string) (Cursor, error) { + var c Cursor + b, err := base64.RawURLEncoding.DecodeString(s) + if err != nil { + return c, ErrInvalidCursor + } + if err := json.Unmarshal(b, &c); err != nil { + return c, ErrInvalidCursor + } + if c.Scope == "" || c.ID == "" || c.TS.IsZero() { + return c, ErrInvalidCursor + } + return c, nil +} + +func lessPair(ai time.Time, aid string, bi time.Time, bid string) bool { + if !ai.Equal(bi) { + return ai.Before(bi) + } + return aid < bid +} + +// paginate — дженерик листания для списков, собранных в памяти (список чатов). +// История сообщений листается НА СТОРОНЕ SQL (см. ListMessages) — там курсор +// превращается в WHERE (created_at, id) > (...), чтобы не тянуть всю ленту. +func paginate[T any](all []T, limit int, cur *Cursor, key func(T) (time.Time, string)) ([]T, bool) { + start := 0 + if cur != nil { + start = sort.Search(len(all), func(i int) bool { + t, id := key(all[i]) + return lessPair(cur.TS, cur.ID, t, id) + }) + } + rest := all[start:] + if len(rest) > limit { + return rest[:limit], true + } + return rest, false +} + +// ─────────────── Пароли: KDF scrypt ─────────────── +// Почему не SHA-256: пароль имеет НИЗКУЮ энтропию (человеческий) и перебирается +// по словарю; медленный KDF с памятью (scrypt) делает перебор дорогим. +// Формат строки самоописываемый: scrypt$N$r$p$salt$hash — параметры едут вместе +// с хэшем, поэтому в lab7 сможем мигрировать на Argon2id, не сломав старые пароли. + +const ( + scryptN = 32768 // 2^15 + scryptR = 8 + scryptP = 1 + scryptKeyLen = 32 + saltLen = 16 +) + +func HashPassword(password string) (string, error) { + salt := make([]byte, saltLen) + if _, err := rand.Read(salt); err != nil { // криптографически стойкая соль + return "", err + } + h, err := scrypt.Key([]byte(password), salt, scryptN, scryptR, scryptP, scryptKeyLen) + if err != nil { + return "", err + } + enc := base64.RawStdEncoding.EncodeToString + return fmt.Sprintf("scrypt$%d$%d$%d$%s$%s", scryptN, scryptR, scryptP, enc(salt), enc(h)), nil +} + +func VerifyPassword(password, encoded string) bool { + parts := strings.Split(encoded, "$") + if len(parts) != 6 || parts[0] != "scrypt" { + return false + } + N, e1 := strconv.Atoi(parts[1]) + r, e2 := strconv.Atoi(parts[2]) + p, e3 := strconv.Atoi(parts[3]) + if e1 != nil || e2 != nil || e3 != nil { + return false + } + salt, e4 := base64.RawStdEncoding.DecodeString(parts[4]) + want, e5 := base64.RawStdEncoding.DecodeString(parts[5]) + if e4 != nil || e5 != nil { + return false + } + got, err := scrypt.Key([]byte(password), salt, N, r, p, len(want)) + if err != nil { + return false + } + // Constant-time сравнение: не даём атаке по времени узнать префикс хэша. + return subtle.ConstantTimeCompare(want, got) == 1 +} + +// isUniqueViolation — SQLSTATE 23505: нарушение UNIQUE (гонка регистрации). +func isUniqueViolation(err error) bool { + var pgErr *pgconn.PgError + return errors.As(err, &pgErr) && pgErr.Code == "23505" +} + +// ─────────────── Пользователи ─────────────── + +func (s *Store) CreateUser(ctx context.Context, username, displayName, password string) (*model.User, error) { + hash, err := HashPassword(password) + if err != nil { + return nil, err + } + u := &model.User{ID: uuid.NewString(), Username: username, DisplayName: displayName, CreatedAt: model.NowTS()} + _, err = s.pool.Exec(ctx, + `INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1, $2, $3, $4, $5)`, + u.ID, u.Username, u.DisplayName, hash, u.CreatedAt.Time) + if err != nil { + if isUniqueViolation(err) { + return nil, ErrUsernameTaken + } + return nil, err + } + return u, nil +} + +const userCols = `id, username, display_name, created_at` + +func (s *Store) User(ctx context.Context, id string) (*model.User, error) { + var u model.User + var createdAt time.Time + err := s.pool.QueryRow(ctx, `SELECT `+userCols+` FROM users WHERE id = $1`, id). + Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, err + } + u.CreatedAt = model.Timestamp{Time: createdAt.UTC()} + return &u, nil +} + +// UserByCredentials — вход: ищем по username, проверяем KDF-хэш. +// Неизвестный user и неверный пароль дают ОДИН флажок ErrInvalidLogin: +// контракт требует одинаковый 401, не раскрывающий существование учётки. +func (s *Store) UserByCredentials(ctx context.Context, username, password string) (*model.User, error) { + var u model.User + var createdAt time.Time + var hash string + err := s.pool.QueryRow(ctx, + `SELECT `+userCols+`, password_hash FROM users WHERE username = $1`, username). + Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt, &hash) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrInvalidLogin + } + if err != nil { + return nil, err + } + if !VerifyPassword(password, hash) { + return nil, ErrInvalidLogin + } + u.CreatedAt = model.Timestamp{Time: createdAt.UTC()} + return &u, nil +} + +// ─────────────── Сессии ─────────────── + +// CreateSession: opaque-токен = 32 байта crypto/rand (256 бит энтропии), +// клиенту отдаём base64url-строку (43 символа >= minLength 32 из схемы). +// Храним SHA-256(token): утечка БД не раскрывает живые токены. +// Источник истины — Postgres; Redis получает копию с TTL = остаток сессии. +func (s *Store) CreateSession(ctx context.Context, userID string) (string, time.Time, error) { + raw := make([]byte, 32) + if _, err := rand.Read(raw); err != nil { + return "", time.Time{}, err + } + token := base64.RawURLEncoding.EncodeToString(raw) + hash := sha256.Sum256([]byte(token)) + expiresAt := time.Now().UTC().Add(s.sessionTTL) // TTL НЕ продлевается рестартом + _, err := s.pool.Exec(ctx, + `INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, $3)`, + hash[:], userID, expiresAt) + if err != nil { + return "", time.Time{}, err + } + s.cacheSessionPut(ctx, hash, userID, expiresAt) + return token, expiresAt, nil +} + +// SessionUser: токен -> пользователь. Путь: Redis-кэш -> Postgres -> populate кэша. +// Неизвестный/истёкший/отозванный -> ErrNotFound (middleware превратит в 401). +func (s *Store) SessionUser(ctx context.Context, token string) (*model.User, error) { + hash := sha256.Sum256([]byte(token)) + if userID, ok := s.cacheSessionGet(ctx, hash); ok { + return s.User(ctx, userID) + } + var userID string + var expiresAt time.Time + err := s.pool.QueryRow(ctx, + `SELECT user_id, expires_at FROM sessions WHERE token_hash = $1`, hash[:]). + Scan(&userID, &expiresAt) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, err + } + if time.Now().UTC().After(expiresAt) { // ленивая чистка просрочки + _, _ = s.pool.Exec(ctx, `DELETE FROM sessions WHERE token_hash = $1`, hash[:]) + s.cacheSessionDel(ctx, hash) + return nil, ErrNotFound + } + s.cacheSessionPut(ctx, hash, userID, expiresAt) + return s.User(ctx, userID) +} + +// RevokeSession — logout: DELETE строки + DEL кэш-ключа. Повтор -> ErrNotFound -> 401. +func (s *Store) RevokeSession(ctx context.Context, token string) error { + hash := sha256.Sum256([]byte(token)) + if _, err := s.pool.Exec(ctx, `DELETE FROM sessions WHERE token_hash = $1`, hash[:]); err != nil { + return err + } + if s.rdb == nil { + return nil // кэша нет — нечему оставаться живым + } + var err error + for attempt := 1; attempt <= 3; attempt++ { + if err = s.cacheSessionDel(ctx, hash); err == nil { + return nil // DEL подтверждён — токен мёртв и в БД, и в кэше + } + s.log.Warn("redis DEL failed on logout, retrying", "attempt", attempt, "error", err.Error()) + time.Sleep(100 * time.Millisecond) + } + return fmt.Errorf("session cache invalidation failed after retries: %w", err) +} + +// ─────────────── Чаты ─────────────── + +// CreateChat — СОСТАВНАЯ ОПЕРАЦИЯ В ОДНОЙ ТРАНЗАКЦИИ: +// проверка участников -> INSERT chat -> INSERT members -> COMMIT. +// Любая ошибка между шагами => ROLLBACK: «получата» в БД не бывает (уровень 3). +func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []string, callerID string) (*model.Chat, error) { + tx, err := s.pool.Begin(ctx) + if err != nil { + return nil, err + } + defer tx.Rollback(ctx) // после Commit это no-op + + // Все ли участники существуют? ANY($1) сравнивает с массивом uuid за один запрос. + rows, err := tx.Query(ctx, `SELECT id FROM users WHERE id = ANY($1)`, memberIDs) + if err != nil { + return nil, err + } + found := make(map[string]bool, len(memberIDs)) + for rows.Next() { + var id string + if err := rows.Scan(&id); err != nil { + rows.Close() + return nil, err + } + found[id] = true + } + rows.Close() + if err := rows.Err(); err != nil { + return nil, err + } + if len(found) != len(memberIDs) { + return nil, ErrBadMembers // неизвестный участник -> 400 + } + if !found[callerID] { + return nil, ErrBadMembers // вызывающий не в member_ids -> 400 + } + + chat := &model.Chat{ID: uuid.NewString(), Title: title, MemberIDs: memberIDs, CreatedAt: model.NowTS()} + if _, err := tx.Exec(ctx, + `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`, + chat.ID, chat.Title, chat.CreatedAt.Time); err != nil { + return nil, err + } + // unnest($2::uuid[]) вставляет всех участников одним запросом вместо цикла. + if _, err := tx.Exec(ctx, + `INSERT INTO chat_members (chat_id, user_id) SELECT $1, unnest($2::uuid[])`, + chat.ID, memberIDs); err != nil { + return nil, err + } + if err := tx.Commit(ctx); err != nil { + return nil, err + } + return chat, nil +} + +// ChatForUser: «нет чата» и «чужой чат» дают ОДИН ErrNotFound -> наружу 404, +// существование чужого чата не раскрывается (запрет 403 из README). +func (s *Store) ChatForUser(ctx context.Context, chatID, userID string) (*model.Chat, error) { + var c model.Chat + var createdAt time.Time + var members []string + err := s.pool.QueryRow(ctx, ` + SELECT c.id, c.title, c.created_at, + (SELECT array_agg(cm.user_id) FROM chat_members cm WHERE cm.chat_id = c.id) + FROM chats c + WHERE c.id = $1 + AND EXISTS (SELECT 1 FROM chat_members cm + WHERE cm.chat_id = c.id AND cm.user_id = $2)`, + chatID, userID).Scan(&c.ID, &c.Title, &createdAt, &members) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + if err != nil { + return nil, err + } + c.CreatedAt = model.Timestamp{Time: createdAt.UTC()} + c.MemberIDs = members + return &c, nil +} + +// ListChats: только чаты пользователя («списки содержат только доступные объекты»), +// сортировка (created_at, id) на стороне SQL; курсорная нарезка — в Go (списки малы). +func (s *Store) ListChats(ctx context.Context, userID string, limit int, cur *Cursor) ([]*model.Chat, bool, error) { + rows, err := s.pool.Query(ctx, ` + SELECT c.id, c.title, c.created_at, array_agg(cm.user_id) + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + WHERE c.id IN (SELECT chat_id FROM chat_members WHERE user_id = $1) + GROUP BY c.id + ORDER BY c.created_at, c.id`, userID) + if err != nil { + return nil, false, err + } + defer rows.Close() + all := make([]*model.Chat, 0, 8) + for rows.Next() { + var c model.Chat + var createdAt time.Time + var members []string + if err := rows.Scan(&c.ID, &c.Title, &createdAt, &members); err != nil { + return nil, false, err + } + c.CreatedAt = model.Timestamp{Time: createdAt.UTC()} + c.MemberIDs = members + all = append(all, &c) + } + if err := rows.Err(); err != nil { + return nil, false, err + } + items, more := paginate(all, limit, cur, func(c *model.Chat) (time.Time, string) { + return c.CreatedAt.Time, c.ID + }) + return items, more, nil +} + +// ─────────────── Сообщения ─────────────── + +// CreateMessage: транзакция «проверка членства -> INSERT». После COMMIT запись +// видна следующему чтению (read-after-write из контракта); затем, в режиме +// versioned, bumpChatVersion инвалидирует кэш истории (трек 5). +func (s *Store) CreateMessage(ctx context.Context, chatID, senderID, text string) (*model.Message, error) { + tx, err := s.pool.Begin(ctx) + if err != nil { + return nil, err + } + defer tx.Rollback(ctx) + + var one int + err = tx.QueryRow(ctx, + `SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, senderID).Scan(&one) + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound // посторонний -> 404 + } + if err != nil { + return nil, err + } + + m := &model.Message{ID: uuid.NewString(), ChatID: chatID, SenderID: senderID, Text: text, CreatedAt: model.NowTS()} + if _, err := tx.Exec(ctx, + `INSERT INTO messages (id, chat_id, sender_id, text, created_at) VALUES ($1,$2,$3,$4,$5)`, + m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt.Time); err != nil { + return nil, err + } + if err := tx.Commit(ctx); err != nil { + return nil, err + } + // Инвалидация кэша истории ТОЛЬКО в защищённом режиме: в naive специально + // не инвалидируем, чтобы продемонстрировать stale read в эксперименте. + if s.cacheMode == "versioned" { + s.bumpChatVersion(ctx, chatID) + } + return m, nil +} + +// ListMessages — keyset-пагинация НА СТОРОНЕ SQL с кэшем истории в Redis. +// Режимы (CACHE_MODE): +// +// off — кэш выключен: каждый запрос идёт в SQL (baseline для замеров); +// naive — кэш БЕЗ версионирования и без single-flight: демонстрация +// stale read и cache stampede (проблема, которую решаем); +// versioned — защита: ключ содержит версию чата (bump на COMMIT записи), +// холодные чтения схлопываются single-flight'ом. +// +// Сам SQL-запрос: WHERE chat_id=$1 AND (created_at, id) > ($2,$3) +// ORDER BY created_at, id LIMIT n+1 — использует индекс messages_history_idx +// (Index Scan, а не Seq Scan; обоснование в evidence/explain_plans.md). +// LIMIT n+1: лишняя строка = флаг hasMore без второго COUNT-запроса. +func (s *Store) ListMessages(ctx context.Context, chatID string, limit int, cur *Cursor) ([]*model.Message, bool, error) { + cursorJSON := EncodeCursorJSON(cur) + useCache := s.rdb != nil && s.cacheMode != "off" + + version := int64(0) + if useCache && s.cacheMode == "versioned" { + version = s.ChatVersion(ctx, chatID) + } + key := HistoryCacheKey(chatID, version, cursorJSON, limit) + + // Попытка 1: кэш. Hit не идёт в SQL вообще — это и есть экономия запросов. + if useCache { + if items, hasMore, ok := s.CacheHistoryGet(ctx, key); ok { + s.log.Info("cache_hit", "chat_id", chatID, "mode", s.cacheMode, "cursor", cursorJSON) + return items, hasMore, nil + } + } + + type pageResult struct { + items []*model.Message + hasMore bool + } + fetch := func() (any, error) { + // Счётчик SQL-запросов для эксперимента: одна строка лога на реальный SELECT. + s.log.Info("sql_list_messages", "chat_id", chatID, "cursor", cursorJSON, "limit", limit) + q := `SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1` + args := []any{chatID} + if cur != nil { + q += ` AND (created_at, id) > ($2, $3)` // строго после закладки: повторов нет + args = append(args, cur.TS, cur.ID) + } + q += ` ORDER BY created_at, id LIMIT $` + strconv.Itoa(len(args)+1) + args = append(args, limit+1) + + rows, err := s.pool.Query(ctx, q, args...) + if err != nil { + return nil, err + } + defer rows.Close() + items := make([]*model.Message, 0, limit) + for rows.Next() { + var m model.Message + var createdAt time.Time + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &createdAt); err != nil { + return nil, err + } + m.CreatedAt = model.Timestamp{Time: createdAt.UTC()} + items = append(items, &m) + } + if err := rows.Err(); err != nil { + return nil, err + } + more := len(items) > limit + if more { + items = items[:limit] + } + return pageResult{items: items, hasMore: more}, nil + } + + var res any + var err error + if useCache && s.cacheMode == "versioned" { + // Stampede-защита: при конкурирующих холодных чтениях одного ключа + // в SQL идёт ровно один запрос, остальные ждут его результат. + res, err = s.sf.Do(key, fetch) + } else { + res, err = fetch() // naive/off: каждый miss идёт в SQL + } + if err != nil { + return nil, false, err + } + pr := res.(pageResult) + if useCache { + s.CacheHistoryPut(ctx, key, pr.items, pr.hasMore) + } + return pr.items, pr.hasMore, nil +} + +// IsUnavailable — «БД недоступна» (пул закрыт, таймаут, ошибка подключения). +// Отличаем от бизнес-ошибок, чтобы отдать 503, а не 500/401. +func IsUnavailable(err error) bool { + if err == nil { + return false + } + var connErr *pgconn.ConnectError + var netErr net.Error + if errors.As(err, &connErr) { + return true + } + if errors.As(err, &netErr) && netErr.Timeout() { + return true + } + errStr := err.Error() + return strings.Contains(errStr, "connection refused") || + strings.Contains(errStr, "connection reset") || + strings.Contains(errStr, "pool closed") || + strings.Contains(errStr, "acquire timeout") || + strings.Contains(errStr, "no connection") +} diff --git a/student-tests/bench.py b/student-tests/bench.py new file mode 100644 index 00000000..d882be94 --- /dev/null +++ b/student-tests/bench.py @@ -0,0 +1,276 @@ +#!/usr/bin/env python3 +"""Track 1 bench: матрица нагрузка x размер истории для in-memory store. +Только stdlib. Пример: +python student-tests/bench.py --label before --container mtusi-messenger-lab1 +""" +import argparse +import csv +import http.client +import json +import subprocess +import threading +import time +import uuid + + +class Client: + def __init__(self, host, port, user_id=None): + self.host, self.port, self.user_id = host, port, user_id + self.conn = None + + def _ensure(self): + if self.conn is None: + self.conn = http.client.HTTPConnection(self.host, self.port, timeout=30) + + def request(self, method, path, body=None): + headers = {} + data = None + if body is not None: + headers["Content-Type"] = "application/json" + data = json.dumps(body).encode() + if self.user_id: + headers["X-User-Id"] = self.user_id + for attempt in (0, 1): + try: + self._ensure() + self.conn.request(method, path, body=data, headers=headers) + resp = self.conn.getresponse() + payload = resp.read() + return resp.status, (json.loads(payload) if payload else None) + except Exception: + self.conn = None + if attempt: + raise + time.sleep(0.05) + + +class Phase: + def __init__(self): + self.lock = threading.Lock() + self.lat = [] + self.errors = 0 + self.requests = 0 + + def add(self, ms, ok): + with self.lock: + self.lat.append(ms) + self.requests += 1 + if not ok: + self.errors += 1 + + def row(self): + with self.lock: + lat = sorted(self.lat) + n = len(lat) + if n == 0: + return 0, 0, 0, 0 + def p(q): + return lat[min(n - 1, int((q * n) // 100))] + return n, p(50), p(95), p(99) + + +class RssSampler: + def __init__(self, container, interval=2.0): + self.container, self.interval = container, interval + self.samples = [] + self.stop = threading.Event() + self.th = threading.Thread(target=self._run, daemon=True) + + def _run(self): + while not self.stop.is_set(): + try: + out = subprocess.run( + ["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", self.container], + capture_output=True, text=True, timeout=10).stdout.strip().splitlines() + if out: + self.samples.append(parse_mib(out[0].split("/")[0].strip())) + except Exception: + pass + self.stop.wait(self.interval) + + def start(self): + self.th.start() + return self + + def finish(self): + self.stop.set() + self.th.join(timeout=5) + if not self.samples: + return 0.0, 0.0 + return sum(self.samples) / len(self.samples), max(self.samples) + + +def parse_mib(s): + s = s.strip() + if s.endswith("GiB"): + return float(s[:-3]) * 1024 + if s.endswith("MiB"): + return float(s[:-3]) + if s.endswith("KiB"): + return float(s[:-4]) / 1024 + return 0.0 + + +def run_phase(host, port, clients, duration, op): + ph = Phase() + deadline = time.perf_counter() + duration + + def worker(idx): + c = Client(host, port, op_user(idx)) + while time.perf_counter() < deadline: + t0 = time.perf_counter() + ok = op(c, idx) + ph.add((time.perf_counter() - t0) * 1000.0, ok) + + threads = [threading.Thread(target=worker, args=(i,)) for i in range(clients)] + for t in threads: + t.start() + for t in threads: + t.join() + return ph + + +USERS = [] + + +def op_user(idx): + return USERS[idx % len(USERS)] + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--label", required=True) + ap.add_argument("--container", default="mtusi-messenger-lab1") + ap.add_argument("--sizes", default="10000,50000,150000") + ap.add_argument("--clients", default="8,32,96") + ap.add_argument("--duration", type=float, default=10.0) + ap.add_argument("--out", default="student-tests/results") + args = ap.parse_args() + + hostport = args.base_url.split("://")[-1].split("/") + host, _, port = hostport[0].partition(":") + port = int(port or 80) + sizes = [int(x) for x in args.sizes.split(",")] + clients = [int(x) for x in args.clients.split(",")] + os_makedirs(args.out) + + admin = Client(host, port) + global USERS + n_users = max(clients) + for i in range(n_users): + st, body = admin.request("POST", "/api/v1/users", + {"username": "b" + uuid.uuid4().hex[:12], "display_name": "Bench"}) + assert st == 201, (st, body) + USERS.append(body["id"]) + + admin.user_id = USERS[0] # <-- ДОБАВИТЬ ЭТУ СТРОКУ: чаты создаёт участник + + st, chat = admin.request("POST", "/api/v1/chats", + {"title": "bench", "member_ids": USERS}) + assert st == 201, (st, chat) + chat_id = chat["id"] + st, chat2 = admin.request("POST", "/api/v1/chats", + {"title": "bench-writes", "member_ids": USERS}) + assert st == 201 + chat2_id = chat2["id"] + + rows = [] + have = 0 + for H in sizes: + # досеиваем историю до H (кумулятивно, экономим время) + if H > have: + seed(host, port, chat_id, H - have) + have = H + for C in clients: + print(f"[{args.label}] read H={H} C={C} ...", flush=True) + rss = RssSampler(args.container).start() + ph = run_phase(host, port, C, args.duration, make_read_op(chat_id)) + avg, mx = rss.finish() + n, p50, p95, p99 = ph.row() + rows.append([args.label, "read", H, C, args.duration, n, ph.errors, + round(n / args.duration, 1), p50, p95, p99, round(avg, 1), round(mx, 1)]) + for C in clients: + print(f"[{args.label}] write C={C} ...", flush=True) + rss = RssSampler(args.container).start() + ph = run_phase(host, port, C, args.duration, make_write_op(chat2_id)) + avg, mx = rss.finish() + n, p50, p95, p99 = ph.row() + rows.append([args.label, "write", 0, C, args.duration, n, ph.errors, + round(n / args.duration, 1), p50, p95, p99, round(avg, 1), round(mx, 1)]) + + path = f"{args.out}/{args.label}.csv" + with open(path, "w", newline="", encoding="utf-8") as f: + w = csv.writer(f) + w.writerow(["label", "phase", "history", "clients", "duration_s", "requests", + "errors", "rps", "p50_ms", "p95_ms", "p99_ms", "rss_avg_mib", "rss_max_mib"]) + w.writerows(rows) + print(f"saved {path}") + + +def os_makedirs(p): + import os + os.makedirs(p, exist_ok=True) + + +def seed(host, port, chat_id, count): + threads_n = 16 + per = count // threads_n + lock = threading.Lock() + state = {"done": 0, "errors": 0} + t0 = time.perf_counter() + + def worker(idx): + c = Client(host, port, USERS[0]) + for j in range(per): + st, _ = c.request("POST", f"/api/v1/chats/{chat_id}/messages", + {"text": f"seed-{idx}-{j}"}) + with lock: + state["done"] += 1 + if st != 201: + state["errors"] += 1 + + threads = [threading.Thread(target=worker, args=(i,)) for i in range(threads_n)] + for t in threads: + t.start() + for t in threads: + t.join() + dt = time.perf_counter() - t0 + print(f" seeded {state['done']} msgs in {dt:.1f}s " + f"({state['done']/dt:.0f} rps, errors={state['errors']})", flush=True) + + +def make_read_op(chat_id): + cursors = {} + + def op(c, idx): + cur = cursors.get(idx) + path = f"/api/v1/chats/{chat_id}/messages?limit=50" + if cur: + path += "&cursor=" + cur + st, body = c.request("GET", path) + if st != 200: + cursors[idx] = None + return False + cursors[idx] = body.get("next_cursor") + return True + + return op + + +def make_write_op(chat_id): + counter = {"i": 0} + lock = threading.Lock() + + def op(c, idx): + with lock: + counter["i"] += 1 + i = counter["i"] + st, _ = c.request("POST", f"/api/v1/chats/{chat_id}/messages", {"text": f"w{i}"}) + return st == 201 + + return op + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/cache_consistency.py b/student-tests/cache_consistency.py new file mode 100644 index 00000000..1d75bbb0 --- /dev/null +++ b/student-tests/cache_consistency.py @@ -0,0 +1,229 @@ +#!/usr/bin/env python3 +"""Трек 5: согласованность кэша истории. Фазы (переключаются bat-ом через CACHE_MODE): + off — baseline: кэша нет. 32 конкурентных холодных чтения = ~32 SQL + (демонстрация cache stampede «до»), 100 последовательных чтений = 100 SQL, + latency p50/p95/p99 «до». + naive — кэш БЕЗ инвалидации версией: ожидаем НАБЛЮДАТЬ stale read + (запись не видна из тёплого кэша). Это демонстрация проблемы согласованности. + versioned — защищённый кэш: read-after-write OK; 32 конкурентных холодных чтения + схлопываются single-flight'ом в 1 SQL (защита от stampede «после»); + 100 тёплых чтений обслуживает кэш (sql<=2), latency «после». + recovery — restart redis: сессия и read-after-write корректны, кэш перестраивается. +Запуск: scripts/cache_demo.bat (сам переключает CACHE_MODE и перезапускает api). +""" +import argparse +import base64 +import json +import subprocess +import threading +import time +import urllib.error +import urllib.request +import uuid + +FAILURES = [] +BASE = "http://localhost:8080" +PASSWORD = "Example-only-not-a-real-secret-123" +READS = 100 # последовательных чтений для SQL-счётчика и latency +STAMPEDE = 32 # конкурентных холодных чтений + + +def check(name, cond, detail=""): + if not cond: + FAILURES.append(name) + print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f" -- {detail}" if not cond and detail else "")) + + +def sh(cmd): + subprocess.run(cmd, shell=True, check=True, capture_output=True) + + +def req(method, path, body=None, token=None, basic=None): + headers, data = {}, None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json" + if token: + headers["Authorization"] = "Bearer " + token + if basic: + headers["Authorization"] = "Basic " + base64.b64encode(basic.encode()).decode() + r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(r, timeout=30) as resp: + payload = resp.read().decode() + return resp.status, (json.loads(payload) if payload else None) + except urllib.error.HTTPError as e: + payload = e.read().decode() + try: + return e.code, json.loads(payload) + except ValueError: + return e.code, None + + +def wait_ready(timeout=90, want=200): + deadline = time.time() + timeout + while time.time() < deadline: + st, _ = req("GET", "/health/ready") + if st == want: + return True + time.sleep(1) + return False + + +def register_login(): + uname = "t5" + uuid.uuid4().hex[:10] + st, _ = req("POST", "/api/v1/users", {"username": uname, "display_name": "T5", "password": PASSWORD}) + assert st == 201, st + st, sess = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}") + assert st == 201, st + return sess["token"], sess["user"]["id"] + + +def setup_chat(token, uid, n): + st, chat = req("POST", "/api/v1/chats", + {"title": "track5-" + uuid.uuid4().hex[:8], "member_ids": [uid]}, token=token) + assert st == 201, st + for i in range(n): + st, _ = req("POST", f"/api/v1/chats/{chat['id']}/messages", + {"text": f"t5-{i:03d}"}, token=token) + assert st == 201, st + return chat + + +def read_page(token, chat_id): + st, body = req("GET", f"/api/v1/chats/{chat_id}/messages?limit=50", token=token) + assert st == 200, (st, body) + return body + + +def sql_count(since_unix, chat_id): + out = subprocess.run(f"docker compose logs api --since {since_unix}", + shell=True, capture_output=True, text=True).stdout + return sum(1 for line in out.splitlines() + if "sql_list_messages" in line and chat_id in line) + + +def concurrent_burst(token, chat_id): + """32 конкурентных холодных чтения через barrier; возвращает число SQL-запросов.""" + since = str(int(time.time())) + barrier = threading.Barrier(STAMPEDE) + + def reader(): + barrier.wait() + read_page(token, chat_id) + + ts = [threading.Thread(target=reader) for _ in range(STAMPEDE)] + for t in ts: + t.start() + for t in ts: + t.join() + return sql_count(since, chat_id) + + +def pctl(xs): + xs = sorted(xs) + n = len(xs) + + def p(q): + return xs[min(n - 1, int(q * n // 100))] + + return round(p(50), 2), round(p(95), 2), round(p(99), 2) + + +def phase_off(): + token, uid = register_login() + chat = setup_chat(token, uid, 5) + # Stampede БЕЗ кэша: каждый из 32 конкурентных читателей идёт в SQL. + n_burst = concurrent_burst(token, chat["id"]) + check("off: concurrent cold reads -> each hits SQL (stampede without cache)", + n_burst >= STAMPEDE // 2, f"sql={n_burst} clients={STAMPEDE}") + # Baseline: каждое последовательное чтение = SQL. + since = str(int(time.time())) + lats = [] + for _ in range(READS): + t0 = time.perf_counter() + read_page(token, chat["id"]) + lats.append((time.perf_counter() - t0) * 1000) + n = sql_count(since, chat["id"]) + check("off: every read hits SQL", n >= READS * 0.9, f"sql={n} reads={READS}") + p50, p95, p99 = pctl(lats) + print(f"RESULT mode=off reads={READS} sql={n} stampede_sql={n_burst} p50={p50} p95={p95} p99={p99}") + + +def phase_naive(): + token, uid = register_login() + # Stale read: тёплый кэш + запись + повторное чтение. + chat = setup_chat(token, uid, 2) + read_page(token, chat["id"]) # прогрев кэша + req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "stale-probe"}, token=token) + page = read_page(token, chat["id"]) + visible = any(m["text"] == "stale-probe" for m in page["items"]) + check("naive: stale read OBSERVED (cache returned old page after write)", not visible, + f"visible={visible}") + print(f"RESULT mode=naive stale_observed={not visible}") + + +def phase_versioned(): + token, uid = register_login() + # Read-after-write: запись видна сразу даже при тёплом кэше. + chat = setup_chat(token, uid, 2) + read_page(token, chat["id"]) + req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "stale-probe"}, token=token) + page = read_page(token, chat["id"]) + visible = any(m["text"] == "stale-probe" for m in page["items"]) + check("versioned: read-after-write OK (no stale)", visible) + # Stampede ПОД защитой: single-flight схлопывает 32 холодных чтения в 1 SQL. + chat2 = setup_chat(token, uid, 5) + n_burst = concurrent_burst(token, chat2["id"]) + check("versioned: single-flight -> exactly 1 SQL on cold key", n_burst == 1, + f"sql={n_burst} clients={STAMPEDE}") + # Тёплые чтения обслуживает кэш. + since = str(int(time.time())) + lats = [] + for _ in range(READS): + t0 = time.perf_counter() + read_page(token, chat["id"]) + lats.append((time.perf_counter() - t0) * 1000) + n = sql_count(since, chat["id"]) + check("versioned: warm reads served from cache", n <= 2, f"sql={n} reads={READS}") + p50, p95, p99 = pctl(lats) + print(f"RESULT mode=versioned reads={READS} sql={n} stampede_sql={n_burst} p50={p50} p95={p95} p99={p99}") + + +def phase_recovery(): + token, uid = register_login() + chat = setup_chat(token, uid, 3) + read_page(token, chat["id"]) + sh("docker compose restart redis") + check("recovery: api ready after redis restart", wait_ready(90, 200)) + st, _ = req("GET", "/api/v1/users/me", token=token) + check("recovery: session still valid (source of truth = postgres)", st == 200, str(st)) + since = str(int(time.time())) + page = read_page(token, chat["id"]) + check("recovery: history readable after cache loss", len(page["items"]) == 3) + req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "after-restart"}, token=token) + page = read_page(token, chat["id"]) + check("recovery: read-after-write OK with rebuilt cache", + any(m["text"] == "after-restart" for m in page["items"])) + n = sql_count(since, chat["id"]) + check("recovery: cache rebuilds (1 sql for 2 reads)", n == 1, f"sql={n}") + print(f"RESULT mode=recovery sql_after_restart={n}") + + +def main(): + global BASE + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default=BASE) + ap.add_argument("--phase", required=True, choices=["off", "naive", "versioned", "recovery"]) + a = ap.parse_args() + BASE = a.base_url + {"off": phase_off, "naive": phase_naive, + "versioned": phase_versioned, "recovery": phase_recovery}[a.phase]() + if FAILURES: + print(f"PHASE {a.phase} FAILED: {FAILURES}") + raise SystemExit(1) + print(f"PHASE {a.phase} DONE") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/compare.py b/student-tests/compare.py new file mode 100644 index 00000000..d2f4d2c2 --- /dev/null +++ b/student-tests/compare.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +"""Сравнение двух label'ов: python student-tests/compare.py --before before --after after""" +import argparse +import csv + + +def load(path): + d = {} + with open(path, newline="", encoding="utf-8") as f: + for r in csv.DictReader(f): + d[(r["phase"], r["history"], r["clients"])] = r + return d + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--before", required=True) + ap.add_argument("--after", required=True) + ap.add_argument("--results", default="student-tests/results") + ap.add_argument("--out", default="student-tests/results/summary.md") + args = ap.parse_args() + + b = load(f"{args.results}/{args.before}.csv") + a = load(f"{args.results}/{args.after}.csv") + lines = [f"# Трек 1: сравнение `{args.before}` → `{args.after}`", ""] + + for phase in ("read", "write"): + keys = sorted(k for k in b if k[0] == phase and k in a) + if not keys: + continue + lines.append(f"## Фаза `{phase}`") + lines.append("") + lines.append("| H | C | rps до | rps после | Δ rps | p95 до | p95 после | p99 до | p99 после | RSS max до | RSS max после |") + lines.append("|---|---|---|---|---|---|---|---|---|---|---|") + for k in keys: + rb, ra = b[k], a[k] + dr = (float(ra["rps"]) - float(rb["rps"])) / float(rb["rps"]) * 100 if float(rb["rps"]) else 0 + lines.append(f"| {k[1]} | {k[2]} | {rb['rps']} | {ra['rps']} | {dr:+.0f}% | " + f"{rb['p95_ms']} | {ra['p95_ms']} | {rb['p99_ms']} | {ra['p99_ms']} | " + f"{rb['rss_max_mib']} | {ra['rss_max_mib']} |") + lines.append("") + + with open(args.out, "w", encoding="utf-8") as f: + f.write("\n".join(lines) + "\n") + print("\n".join(lines)) + print(f"\nsaved {args.out}") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/expiry_checks.py b/student-tests/expiry_checks.py new file mode 100644 index 00000000..d5a002f3 --- /dev/null +++ b/student-tests/expiry_checks.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +"""Проверка expiry при коротком SESSION_TTL_SECONDS (стенд поднят скриптом). + +Устойчивость к медленному старту после перезапуска api: + - заголовки ищем в lower-case (Go шлёт "Www-Authenticate", а не "WWW-Authenticate"); + - логин повторяется, пока на сессии не останется достаточный запас времени, + иначе «свежий» запрос ловил 401 из-за гонки времени при очень коротком TTL. +""" +import argparse +import base64 +import json +import time +import urllib.error +import urllib.request +import uuid +from datetime import datetime, timezone + +BASE = "http://localhost:8080" +PASSWORD = "Example-only-not-a-real-secret-123" +FAILURES = [] + + +def check(name, cond, detail=""): + if not cond: + FAILURES.append(name) + print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f" -- {detail}" if not cond and detail else "")) + + +def _lower_headers(headers): + """Ключи заголовков в нижнем регистре: регистр присылки не важен.""" + return {k.lower(): v for k, v in headers.items()} + + +def www_auth(hdr): + return hdr.get("www-authenticate", "") + + +def req(method, path, body=None, token=None, basic=None): + headers, data = {}, None + if body is not None: + data = json.dumps(body).encode() + headers["Content-Type"] = "application/json" + if token: + headers["Authorization"] = "Bearer " + token + if basic: + headers["Authorization"] = "Basic " + base64.b64encode(basic.encode()).decode() + r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(r, timeout=10) as resp: + p = resp.read().decode() + return resp.status, _lower_headers(resp.headers), (json.loads(p) if p else None) + except urllib.error.HTTPError as e: + p = e.read().decode() + try: + return e.code, _lower_headers(e.headers), json.loads(p) + except ValueError: + return e.code, _lower_headers(e.headers), None + + +def seconds_left(sess): + """Сколько секунд осталось до истечения — по expires_at из ответа сервера.""" + exp = datetime.fromisoformat(sess["expires_at"].replace("Z", "+00:00")) + return (exp - datetime.now(timezone.utc)).total_seconds() + + +def login_fresh(uname, min_left=1.5, attempts=5): + """Логин с повторами, пока на сессии не останется >= min_left секунд. + Защита от медленных первых запросов сразу после перезапуска контейнера.""" + sess = None + for i in range(attempts): + st, _, sess = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}") + assert st == 201, f"login failed: {st} {sess}" + if seconds_left(sess) >= min_left: + return sess + time.sleep(0.3) + return sess # последний вариант, даже если запас мал + + +def main(): + global BASE + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default=BASE) + BASE = ap.parse_args().base_url + + uname = "exp" + uuid.uuid4().hex[:10] + st, _, body = req("POST", "/api/v1/users", + {"username": uname, "display_name": "EX", "password": PASSWORD}) + assert st == 201, f"register failed: {st} {body}" + + sess = login_fresh(uname) + check("login 201 with short TTL", True) + token = sess["token"] + + # Свежий токен обязан работать сразу после логина. + st, _, _ = req("GET", "/api/v1/users/me", token=token) + check("fresh token 200", st == 200, str(st)) + + # Ждём гарантированного истечения: реальный остаток + 1 с запаса. + wait = seconds_left(sess) + 1.0 + time.sleep(max(wait, 0.5)) + + st, hdr, _ = req("GET", "/api/v1/users/me", token=token) + check("expired token -> 401", st == 401, str(st)) + check("expired WWW-Authenticate Bearer", www_auth(hdr).startswith("Bearer"), + f"got {www_auth(hdr)!r}") + + st, _, _ = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}") + check("re-login after expiry 201", st == 201) + + if FAILURES: + print(f"FAILED {len(FAILURES)}: {FAILURES}") + raise SystemExit(1) + print("EXPIRY CHECKS PASSED") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/explain.sql b/student-tests/explain.sql new file mode 100644 index 00000000..428279fb --- /dev/null +++ b/student-tests/explain.sql @@ -0,0 +1,10 @@ +-- План запроса keyset-пагинации истории: первая страница (курсор = начало времён). +-- Ожидаем WITH index: Limit -> Index Scan using messages_history_idx +-- Ожидаем WITHOUT index: Limit -> Sort -> Seq Scan on messages +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = :'chat' + AND (created_at, id) > ('2020-01-01T00:00:00+00', '00000000-0000-0000-0000-000000000000') +ORDER BY created_at, id + LIMIT 51; \ No newline at end of file diff --git a/student-tests/failover_tests.py b/student-tests/failover_tests.py new file mode 100644 index 00000000..01bfa696 --- /dev/null +++ b/student-tests/failover_tests.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python3 +"""Уровень 4: деградация при потере сервисов. +Redis down -> API обслуживает запросы через SQL (200), логи warn. +Postgres down -> /health/ready 503 и защищённые запросы 503 (не 200, не «аноним доверен»). +Запуск из корня репозитория: +python student-tests/failover_tests.py --base-url http://localhost:8080 +""" +import argparse +import base64 +import json +import subprocess +import time +import urllib.error +import urllib.request +import uuid + +FAILURES = [] +BASE = "http://localhost:8080" +PASSWORD = "Example-only-not-a-real-secret-123" + + +def check(name, cond, detail=""): + if not cond: + FAILURES.append(name) + print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f" -- {detail}" if not cond and detail else "")) + + +def sh(cmd): + subprocess.run(cmd, shell=True, check=True, capture_output=True) + + +def req(method, path, body=None, token=None, basic=None): + headers, data = {}, None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json" + if token: + headers["Authorization"] = "Bearer " + token + if basic: + headers["Authorization"] = "Basic " + base64.b64encode(basic.encode()).decode() + r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(r, timeout=10) as resp: + payload = resp.read().decode() + return resp.status, (json.loads(payload) if payload else None) + except urllib.error.HTTPError as e: + payload = e.read().decode() + try: + return e.code, json.loads(payload) + except ValueError: + return e.code, None + + +def wait_ready(timeout=60, want=200): + deadline = time.time() + timeout + while time.time() < deadline: + st, _ = req("GET", "/health/ready") + if st == want: + return True + time.sleep(1) + return False + + +def main(): + global BASE + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default=BASE) + BASE = ap.parse_args().base_url + + # Создаём пользователя + uname = "fo" + uuid.uuid4().hex[:10] # без дефиса + st, body = req("POST", "/api/v1/users", {"username": uname, "display_name": "FO", "password": PASSWORD}) + print(f"DEBUG register: {st} {body}") + assert st == 201, f"register failed: {st} {body}" + + st, sess = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}") + print(f"DEBUG login: {st} {sess}") + assert st == 201, f"login failed: {st} {sess}" + token = sess["token"] + + # Узнаём свой id через /me + me_st, me = req("GET", "/api/v1/users/me", token=token) + print(f"DEBUG /me: {me_st} {me}") + assert me_st == 200, f"/me failed: {me_st} {me}" + + # Создаём чат с самим собой + st, chat = req("POST", "/api/v1/chats", {"title": "failover", "member_ids": [me["id"]]}, token=token) + print(f"DEBUG create chat: {st} {chat}") + assert st == 201, f"create chat failed: {st} {chat}" + + # ── Redis down: деградация в SQL, не отказ ── + sh("docker compose stop redis") + time.sleep(2) + st, _ = req("GET", "/health/ready") + check("redis down: ready stays 200 (cache optional)", st == 200, str(st)) + st, _ = req("GET", "/api/v1/users/me", token=token) + check("redis down: auth via postgres 200", st == 200, str(st)) + st, _ = req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "during redis outage"}, token=token) + check("redis down: write 201", st == 201, str(st)) + st, _ = req("GET", f"/api/v1/chats/{chat['id']}/messages?limit=10", token=token) + check("redis down: read 200", st == 200, str(st)) + sh("docker compose start redis") + check("redis back: ready 200", wait_ready(60, 200)) + + # ── Postgres down: ограниченные ошибки, аноним не доверен ── + sh("docker compose stop postgres") + check("postgres down: ready becomes 503", wait_ready(60, 503)) + st, _ = req("GET", "/api/v1/users/me", token=token) + check("postgres down: protected request 503 (not 200/401)", st == 503, str(st)) + st, _ = req("GET", "/api/v1/users/me") + check("postgres down: anonymous still 401", st == 401, str(st)) + sh("docker compose start postgres") + check("postgres back: ready 200", wait_ready(90, 200)) + st, _ = req("GET", "/api/v1/users/me", token=token) + check("postgres back: same session valid 200", st == 200, str(st)) + + # ── Logout при сбое Redis: никаких «тихих» 204, оставляющих токен живым ── + st, sess2 = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}") + assert st == 201, f"second login failed: {st} {sess2}" + token2 = sess2["token"] + + sh("docker compose stop redis") + time.sleep(2) + st, _ = req("DELETE", "/api/v1/auth/sessions/current", token=token2) + check("redis down: logout returns 503, not silent 204", st == 503, str(st)) + st, _ = req("GET", "/api/v1/users/me", token=token2) + check("redis down: token already revoked in postgres -> 401", st == 401, str(st)) + + sh("docker compose start redis") + check("redis back (2): ready 200", wait_ready(60, 200)) + st, _ = req("DELETE", "/api/v1/auth/sessions/current", token=token2) + check("redis back: logout retry 204 (DEL confirmed)", st == 204, str(st)) + st, _ = req("GET", "/api/v1/users/me", token=token2) + check("after retry logout: token still 401", st == 401, str(st)) + + if FAILURES: + print(f"FAILED {len(FAILURES)}: {FAILURES}") + raise SystemExit(1) + print("ALL FAILOVER TESTS PASSED") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/run_tests.py b/student-tests/run_tests.py new file mode 100644 index 00000000..c0b2a946 --- /dev/null +++ b/student-tests/run_tests.py @@ -0,0 +1,265 @@ +#!/usr/bin/env python3 +"""Студенческие тесты lab2 (Bearer-аутентификация). Одна команда: +python student-tests/run_tests.py --base-url http://localhost:8080 +""" +import argparse +import base64 +import json +import threading +import urllib.error +import urllib.request +import uuid + +FAILURES = [] +BASE = "http://localhost:8080" +PASSWORD = "Example-only-not-a-real-secret-123" # 38 code points: в диапазоне 12..128 + + +def check(name, cond, detail=""): + if not cond: + FAILURES.append(name) + print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f" -- {detail}" if not cond and detail else "")) + + +def _lower_headers(headers): + """Ключи заголовков в нижнем регистре. + Go шлёт WWW-Authenticate как "Www-Authenticate" (каноническая MIME-форма), + а dict(headers) сохраняет регистр как пришёл. Чтобы тест не зависел от + регистра, всегда ищем заголовки в lower-case.""" + return {k.lower(): v for k, v in headers.items()} + + +def www_auth(hdr): + """Значение WWW-Authenticate независимо от регистра ключа.""" + return hdr.get("www-authenticate", "") + + +def req(method, path, body=None, raw=None, token=None, basic=None, + ctype="application/json", extra_headers=None): + headers, data = {}, None + if raw is not None: + data, headers["Content-Type"] = raw.encode("utf-8"), ctype + elif body is not None: + data, headers["Content-Type"] = json.dumps(body, ensure_ascii=False).encode("utf-8"), ctype + if token: + headers["Authorization"] = "Bearer " + token + if basic: + headers["Authorization"] = "Basic " + base64.b64encode(basic.encode("utf-8")).decode("ascii") + if extra_headers: + headers.update(extra_headers) + r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(r, timeout=30) as resp: + payload = resp.read().decode("utf-8") + return resp.status, _lower_headers(resp.headers), (json.loads(payload) if payload else None) + except urllib.error.HTTPError as e: + payload = e.read().decode("utf-8") + try: + return e.code, _lower_headers(e.headers), json.loads(payload) + except ValueError: + return e.code, _lower_headers(e.headers), None + + +def register(username=None, password=PASSWORD, display="Тест Юникод ✓"): + username = username or "u" + uuid.uuid4().hex[:12] + return req("POST", "/api/v1/users", + {"username": username, "display_name": display, "password": password}) + + +def login(username, password=PASSWORD): + return req("POST", "/api/v1/auth/sessions", basic=f"{username}:{password}") + + +def main(): + global BASE + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default=BASE) + BASE = ap.parse_args().base_url + + # ── health и номерки ── + st, hdr, body = req("GET", "/health/live") + check("health live 200", st == 200 and body == {"status": "ok"}) + check("X-Request-Id present", bool(hdr.get("x-request-id"))) + st, _, body = req("GET", "/health/ready") + check("health ready 200", st == 200 and body == {"status": "ok"}) + + # ── валидация регистрации ── + st, _, _ = req("POST", "/api/v1/users", raw='{"username": "abc",') + check("malformed JSON -> 400", st == 400) + st, _, _ = req("POST", "/api/v1/users", + {"username": "extrafield1", "display_name": "x", "password": PASSWORD, "junk": 1}) + check("extra field -> 400", st == 400) + st, _, _ = req("POST", "/api/v1/users", {"username": "BadName", "display_name": "x", "password": PASSWORD}) + check("username pattern -> 400", st == 400) + st, _, _ = req("POST", "/api/v1/users", {"username": "wsname1", "display_name": " ", "password": PASSWORD}) + check("whitespace display_name -> 400", st == 400) + st, _, _ = req("POST", "/api/v1/users", {"username": "shortpw1", "display_name": "x", "password": "short"}) + check("password < 12 -> 400", st == 400) + st, _, _ = req("POST", "/api/v1/users", {"username": "longpw1", "display_name": "x", "password": "x" * 129}) + check("password > 128 -> 400", st == 400) + st, _, _ = req("POST", "/api/v1/users", {"username": "wspw1", "display_name": "x", "password": " "}) + check("whitespace password -> 400", st == 400) + + st, _, alice = register() + check("register 201", st == 201) + check("no password/hash in User response", + isinstance(alice, dict) and "password" not in alice and "password_hash" not in alice) + st2, _, _ = register(username=alice["username"]) + check("duplicate username -> 409", st2 == 409) + + # ── вход: неверные/неизвестные/успех ── + st, hdr, _ = login(alice["username"], "Wrong-" + PASSWORD) + check("wrong password -> 401", st == 401) + check("wrong password WWW-Authenticate Basic", www_auth(hdr).startswith("Basic"), + f"got {www_auth(hdr)!r}") + st, hdr, _ = login("nosuchuser" + uuid.uuid4().hex[:6]) + check("unknown user -> 401 same shape", + st == 401 and www_auth(hdr).startswith("Basic"), f"got {www_auth(hdr)!r}") + st, _, sess = login(alice["username"]) + check("login 201 session", st == 201 and sess["token_type"] == "Bearer" and len(sess["token"]) >= 32) + check("session has expires_at and user", "expires_at" in sess and "user" in sess) + token_a = sess["token"] + + _, _, bob = register(); _, _, sess_b = login(bob["username"]); token_b = sess_b["token"] + _, _, carol = register(); _, _, sess_c = login(carol["username"]); token_c = sess_c["token"] + + # ── правила аутентификации lab2 ── + st, hdr, _ = req("GET", "/api/v1/users/me") + check("no auth -> 401 + Bearer header", + st == 401 and www_auth(hdr).startswith("Bearer"), f"got {www_auth(hdr)!r}") + st, _, _ = req("GET", "/api/v1/users/me", extra_headers={"X-User-Id": alice["id"]}) + check("X-User-Id ignored -> 401", st == 401) + st, hdr, _ = req("GET", "/api/v1/users/me", basic=f"{alice['username']}:{PASSWORD}") + check("Basic on business endpoint -> 401 Bearer", + st == 401 and www_auth(hdr).startswith("Bearer"), f"got {www_auth(hdr)!r}") + st, _, _ = req("GET", "/api/v1/users/me", token="not-a-valid-token") + check("garbage Bearer -> 401", st == 401) + st, _, me = req("GET", "/api/v1/users/me", token=token_a) + check("me with Bearer 200", st == 200 and me["id"] == alice["id"]) + + # ── чаты и доступ ── + st, _, chat = req("POST", "/api/v1/chats", + {"title": "Проект по ВНП", "member_ids": [alice["id"], bob["id"]]}, token=token_a) + check("create chat 201", st == 201) + cid = chat["id"] + st, _, _ = req("GET", f"/api/v1/chats/{cid}", token=token_c) + check("outsider GET chat -> 404", st == 404) + st, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": "hi"}, token=token_c) + check("outsider POST message -> 404", st == 404) + st, _, body = req("GET", "/api/v1/chats", token=token_c) + check("outsider list hides foreign chat", st == 200 and all(c["id"] != cid for c in body["items"])) + + # ── валидация сообщений ── + st, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": ""}, token=token_a) + check("empty text -> 400", st == 400) + st, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": " \n "}, token=token_a) + check("whitespace text -> 400", st == 400) + st, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": "x" * 4001}, token=token_a) + check("text > 4000 -> 400", st == 400) + text = "Привет, Боб! 🚀 Ünïcödé ✓" + st, _, msg = req("POST", f"/api/v1/chats/{cid}/messages", {"text": text}, token=token_a) + check("unicode round-trip exact", st == 201 and msg["text"] == text) + + # ── пагинация ── + for i in range(24): + req("POST", f"/api/v1/chats/{cid}/messages", {"text": f"msg-{i:02d}"}, token=token_b) + hist, cursor, pages = [], None, 0 + while True: + q = f"/api/v1/chats/{cid}/messages?limit=10" + (f"&cursor={cursor}" if cursor else "") + st, _, page = req("GET", q, token=token_b) + pages += 1 + hist.extend(page["items"]) + cursor = page["next_cursor"] + if not cursor: + break + ids = [m["id"] for m in hist] + check("25 msgs -> 3 pages, no repeats", pages == 3 and len(ids) == 25 and len(set(ids)) == 25) + pairs = [(m["created_at"], m["id"]) for m in hist] + bad = [i for i in range(len(pairs) - 1) if pairs[i] > pairs[i + 1]] + check("history ordered by (created_at, id)", not bad, f"{len(bad)} inversions") + + st, _, chat2 = req("POST", "/api/v1/chats", + {"title": "other", "member_ids": [alice["id"], bob["id"]]}, token=token_a) + req("POST", f"/api/v1/chats/{chat2['id']}/messages", {"text": "o1"}, token=token_a) + req("POST", f"/api/v1/chats/{chat2['id']}/messages", {"text": "o2"}, token=token_a) + _, _, p2 = req("GET", f"/api/v1/chats/{chat2['id']}/messages?limit=1", token=token_a) + st, _, _ = req("GET", f"/api/v1/chats/{cid}/messages?limit=10&cursor={p2['next_cursor']}", token=token_a) + check("cursor from another chat -> 400", st == 400) + ok = True + for v in ("0", "101", "abc"): + st, _, _ = req("GET", f"/api/v1/chats/{cid}/messages?limit={v}", token=token_a) + ok = ok and st == 400 + check("limit 0/101/abc -> 400", ok) + + # ── logout и отзыв ── + _, _, sess_b2 = login(bob["username"]) + token_b2 = sess_b2["token"] + st, _, _ = req("DELETE", "/api/v1/auth/sessions/current", token=token_b2) + check("logout -> 204", st == 204) + st, _, _ = req("GET", "/api/v1/users/me", token=token_b2) + check("revoked token -> 401", st == 401) + st, _, _ = req("GET", "/api/v1/users/me", token=token_b) + check("other session of same user still valid", st == 200) + + # ── гонка регистрации: UNIQUE-ограничение (имя БЕЗ дефиса: маска username) ── + race_name = "race" + uuid.uuid4().hex[:10] + results, lock = [], threading.Lock() + def racer(): + s, _, _ = register(username=race_name) + with lock: + results.append(s) + ts = [threading.Thread(target=racer) for _ in range(10)] + for t in ts: t.start() + for t in ts: t.join() + check("race registration: one 201, rest 409", + results.count(201) == 1 and results.count(409) == 9, str(results)) + + # ── rollback составной операции ── + _, _, before = req("GET", "/api/v1/chats", token=token_a) + n_before = len(before["items"]) + st, _, _ = req("POST", "/api/v1/chats", + {"title": "rollback-probe", "member_ids": [alice["id"], str(uuid.uuid4())]}, token=token_a) + check("chat with unknown member -> 400", st == 400) + _, _, after = req("GET", "/api/v1/chats", token=token_a) + check("rollback: no partial chat", + len(after["items"]) == n_before and all(c["title"] != "rollback-probe" for c in after["items"])) + + # ── конкурентные записи ── + errs = [] + def writer(idx): + for j in range(10): + s, _, _ = req("POST", f"/api/v1/chats/{cid}/messages", {"text": f"c{idx}-{j}"}, token=token_b) + if s != 201: + errs.append((idx, j, s)) + ts = [threading.Thread(target=writer, args=(i,)) for i in range(10)] + for t in ts: t.start() + for t in ts: t.join() + check("100 concurrent sends all 201", not errs, str(errs[:5])) + items, cur = [], None + while True: + q = f"/api/v1/chats/{cid}/messages?limit=100" + (f"&cursor={cur}" if cur else "") + st, _, page = req("GET", q, token=token_b) + items.extend(page["items"]) + cur = page["next_cursor"] + if not cur: + break + expected = {f"c{i}-{j}" for i in range(10) for j in range(10)} + got = {m["text"] for m in items} + check("exactly 100 unique concurrent messages", expected <= got and len(got & expected) == 100) + + # ── прочее контрактное ── + st, _, _ = req("POST", "/api/v1/users", + raw='{"username":"cttest1","display_name":"x","password":"' + PASSWORD + '"}', + ctype="text/plain") + check("wrong Content-Type -> 415", st == 415) + st, _, body = req("GET", "/nope") + check("unknown route -> 404 envelope", st == 404 and body and body["error"]["code"] == "not_found") + + if FAILURES: + print(f"FAILED {len(FAILURES)}: {FAILURES}") + raise SystemExit(1) + print("ALL STUDENT TESTS PASSED") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/seed.sql b/student-tests/seed.sql new file mode 100644 index 00000000..49829185 --- /dev/null +++ b/student-tests/seed.sql @@ -0,0 +1,7 @@ +-- Сев 10 000 сообщений в существующий чат. +-- Переменные psql: :chat и :sender (передаются через -v chat=... -v sender=...). +-- created_at разносим в прошлое по секунде на сообщение, чтобы ключ +-- (created_at, id) был плотным и реалистичным для keyset-пагинации. +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), :'chat', :'sender', 'seed-' || g, now() - make_interval(secs => g) +FROM generate_series(1, 10000) AS g; \ No newline at end of file