Shiyan BVT2304 - 4 #48

Closed
BVT2304_Shiyan wants to merge 2 commits from BVT2304_Shiyan/mtusi2026lab2:solution/BVT2304-Shiyan into master
33 changed files with 4089 additions and 18 deletions
+10
View File
@@ -18,3 +18,13 @@ __pycache__
node_modules
evidence
.DS_Store
*.pyc
.idea
.vscode
student-tests/
tests/
contracts/
examples/
scripts/
*.md
Dockerfile.example
+20
View File
@@ -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"]
+411 -16
View File
@@ -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 <timestamp>` |
| Метрика 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>:<chat>:<cursor>:<limit>`, где N = `ChatVersion` из Redis |
| Инвалидация на COMMIT | `store/postgres.go`, `CreateMessage` | после успешного `tx.Commit` вызывается `bumpChatVersion(ctx, chatID)` → INCR счётчика; ключи с v<N-1 становятся «мёртвыми» |
| Single-flight против stampede | `store/cache.go`, `SingleFlight.Do` | `sync.Mutex` + `sync.WaitGroup` на key: при конкурентных miss в SQL идёт один поток, остальные ждут его результат |
| Деградация | `store/cache.go`, все функции | `redisTimeout = 300ms`; при ошибке Redis — `log.Warn` и возврат в SQL, не отказ |
### Ограничения измерения
- Latency измерялась на локальном стенде и отражает **суммарное** время (сеть + JSON + БД/Redis). Доминируют сетевые задержки и JSON-сериализация на клиенте, поэтому p50/p95/p99 в `off` и `versioned` близки (23–26 ms). Для корректного сравнения выигрыша от кэша нужен отдельный бенчмарк внутри процесса API (без HTTP) — за рамками обязательного минимума трека 1.
- Разница видна в **счётчике SQL**: 132 SQL на 100 чтений в `off` против 0 SQL на 100 тёплых чтений в `versioned` — именно это доказывает, что кэш снимает нагрузку с БД.
- Single-flight действует внутри одного процесса API: при нескольких репликах (тема lab3) stampede между процессами возможен.
- Один прогон на фазу без повторов и без сбора CPU/RAM: результаты latency следует считать индикативными, а не статистически значимыми.
- TTL кэша истории = 60 с: достаточно для hot-чтений и достаточно коротко, чтобы не держать устаревшие данные долго.
### Таблица отказов
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose stop redis` | `/health/ready` 200; запросы обслуживаются через SQL | `redis down: ready stays 200`, `auth via postgres 200`, `write 201`, `read 200` | мгновенно; кэш пуст, источник истины не теряется |
| `docker compose start redis` | readiness 200, кэш восстанавливается | `redis back: ready 200` | < 60 с |
| `docker compose stop postgres` | `/health/ready` 503; защищённые запросы 503 | `ready becomes 503`, `protected request 503`, `anonymous still 401` | мгновенно |
| `docker compose start postgres` | readiness 200; та же сессия валидна | `postgres back: same session valid 200` | < 90 с |
| `docker compose restart redis` (фаза recovery) | сессия жива, read-after-write OK | все PASS в recovery-фазе; `sql_after_restart=1` (rebuild кэша) | мгновенно |
| Истечение TTL (`SESSION_TTL_SECONDS=2`, ожидание 3 с) | 401 + `WWW-Authenticate: Bearer` | PASS: `expired token -> 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 под нагрузкой) — измерения не собирались.
+63
View File
@@ -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
+26
View File
@@ -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
+60
View File
@@ -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
+11
View File
@@ -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
+100
View File
@@ -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
+60
View File
@@ -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 истории на каждую страницу.
+10
View File
@@ -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."
+2 -2
View File
@@ -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
+312
View File
@@ -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$<salt>$...`.
**Что доказывает:** пароль хешируется библиотечным 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>:<chat>:<cursor>:<limit>`, где N — счётчик версии чата в Redis.
- На каждый COMMIT записи (`CreateMessage`) выполняется `INCR chatver:<chat>`: старые ключи становятся «мёртвыми», следующее чтение строит ключ с новой версией → 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
```
+136
View File
@@ -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")
}
}
+20
View File
@@ -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
)
+40
View File
@@ -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=
+315
View File
@@ -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"))
}
}
+151
View File
@@ -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 <base64(username:password)>».
// КЛЮЧЕВАЯ ДЕТАЛЬ: пароль может содержать двоеточие, поэтому режем по ПЕРВОЙ «:»
// (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 <token>»; пустой токен не принимаем.
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"))
}
+146
View File
@@ -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) }
+43
View File
@@ -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
}
+65
View File
@@ -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}})
}
+89
View File
@@ -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"`
}
+223
View File
@@ -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)
}
+47
View File
@@ -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
}
@@ -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);
+584
View File
@@ -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")
}
+276
View File
@@ -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()
+229
View File
@@ -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()
+50
View File
@@ -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()
+117
View File
@@ -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()
+10
View File
@@ -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;
+143
View File
@@ -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()
+265
View File
@@ -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()
+7
View File
@@ -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;