This commit is contained in:
+37
@@ -0,0 +1,37 @@
|
||||
# syntax=docker/dockerfile:1
|
||||
|
||||
# --- build stage -------------------------------------------------------
|
||||
# lib/pq, go-redis/v9 и golang.org/x/crypto/argon2 — чистый Go без cgo,
|
||||
# поэтому CGO_ENABLED=0 не ограничивает ничего, что нужно лабе 2.
|
||||
FROM golang:1.22.5-alpine AS build
|
||||
WORKDIR /src
|
||||
|
||||
COPY src/go.mod src/go.sum ./
|
||||
RUN go mod download
|
||||
|
||||
COPY src/ ./
|
||||
# Миграции (migrations/*.up.sql) вшиваются в бинарь через //go:embed в
|
||||
# migrate.go — отдельно копировать их в финальный образ не нужно.
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger .
|
||||
|
||||
# --- runtime stage -------------------------------------------------------
|
||||
# scratch: ни шелла, ни пакетного менеджера, ни единой лишней библиотеки —
|
||||
# минимальная поверхность атаки для процесса, слушающего сеть.
|
||||
FROM scratch
|
||||
|
||||
# Непривилегированный числовой UID:GID (scratch не содержит /etc/passwd,
|
||||
# поэтому именованный пользователь здесь невозможен — используем число
|
||||
# напрямую, как и требует HEALTHCHECK/USER без shell).
|
||||
USER 10001:10001
|
||||
|
||||
COPY --from=build /out/messenger /app/messenger
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
# Самодостаточный healthcheck: в scratch нет curl/wget, поэтому бинарь
|
||||
# сам умеет проверить /health/ready (см. probe() в main.go) и выйти с
|
||||
# кодом 0/1.
|
||||
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \
|
||||
CMD ["/app/messenger", "-healthcheck"]
|
||||
|
||||
ENTRYPOINT ["/app/messenger"]
|
||||
@@ -1,37 +1,102 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: TODO (заполнить самостоятельно — ФИО и номер группы)
|
||||
- Целевая оценка; выбранный трек 5, если нужен: **4** (трек 5 не заявлен)
|
||||
- Commit/PR: TODO после публикации (вставить хэш коммита/ссылку на PR после push в форк)
|
||||
- Использованные источники, библиотеки и помощь ИИ: контракт курса (`contracts/openapi.json`, `contracts/README.md`, `contracts/infrastructure.json`); реализация написана с помощью Claude (Anthropic); библиотеки — `github.com/lib/pq` (драйвер PostgreSQL, выбран вместо `jackc/pgx` из-за недоступности части транзитивных зависимостей pgx в среде разработки), `github.com/redis/go-redis/v9`, `golang.org/x/crypto/argon2` (KDF паролей). Собственный ре-запускаемый runner миграций на `//go:embed` — написан без внешних библиотек (`golang-migrate` сознательно не использован, см. "Ограничения").
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Версии образов зафиксированы в `compose.yaml`: `postgres:16.4-alpine`, `redis:7.4-alpine`; билд `api` — `golang:1.22.5-alpine` → `scratch` (см. `Dockerfile`).
|
||||
|
||||
Prerequisites: Docker + Docker Compose v2.
|
||||
|
||||
1. Секреты для локального/учебного запуска уже лежат в `secrets/*.txt` рабочими значениями (не для продакшена). Чтобы задать свои:
|
||||
```bash
|
||||
printf '<свой пароль>' > secrets/postgres_password.txt
|
||||
printf 'postgres://messenger:<тот же пароль>@postgres:5432/messenger?sslmode=disable' > secrets/database_url.txt
|
||||
printf 'redis://redis:6379/0' > secrets/cache_url.txt
|
||||
```
|
||||
2. Собрать и запустить:
|
||||
```bash
|
||||
docker compose up -d --build
|
||||
```
|
||||
`depends_on: condition: service_healthy` на `postgres`/`redis` не даёт `api` стартовать раньше их готовности; сам `api` ждать явно не нужно — healthcheck в `Dockerfile` (`/app/messenger -healthcheck` → `/health/ready`) сам покажет `healthy`, когда готов (миграции применяются при старте процесса, до начала слушания порта).
|
||||
3. Проверить вручную: `curl -s localhost:8080/health/ready`.
|
||||
4. Публичный smoke (не требует доступа к Postgres с хоста):
|
||||
```bash
|
||||
make test # BASE_URL=http://localhost:8080 по умолчанию
|
||||
```
|
||||
5. Внутренний собственный набор тестов (`go test`) требует **отдельного** доступа к PostgreSQL с хоста по `TEST_DATABASE_URL` — `compose.yaml` сознательно **не** публикует порт `5432` наружу (контейнерный Postgres не должен быть доступен снаружи сети compose). Поэтому для `go test` нужен либо отдельный локальный Postgres 16, либо временно добавить `ports: ["5432:5432"]` к сервису `postgres` в `compose.yaml` на время разработки:
|
||||
```bash
|
||||
cd src
|
||||
export TEST_DATABASE_URL=postgres://messenger:<пароль>@localhost:5432/messenger?sslmode=disable
|
||||
go test -race -count=1 ./...
|
||||
```
|
||||
6. Проверка персистентности (hook — `scripts/restart.sh`, не удаляет volume):
|
||||
```bash
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
# или вручную:
|
||||
docker compose down && docker compose up -d
|
||||
```
|
||||
7. Безопасная остановка (данные остаются): `docker compose down`.
|
||||
8. Намеренное удаление всех учебных данных (отдельная, явно другая команда — делать осознанно): `docker compose down -v`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
**Процессы и источники истины.** `api` — стейтлес Go-процесс (`persistent_local_state: false` по `contracts/infrastructure.json`), без собственного volume. `postgres` — единственный источник истины для users/chats/chat_members/messages/sessions, `persistent_volume: true`. `redis` — необязательный (на уровне 4 — обязательный) read-through кэш **только** сессий, не хранит ничего, что не продублировано в Postgres; падение/потеря Redis не меняет корректность, только скорость.
|
||||
|
||||
**Транзакционные границы:**
|
||||
- Регистрация — защита от race на username через `UNIQUE INDEX`, а не app-level check-then-insert (TOCTOU). Конкурентность проверена 10-горутинным тестом.
|
||||
- Создание чата — одна транзакция (insert в `chats` + insert в `chat_members`), rollback при неизвестном `member_id` (FK-ограничение + явный rollback), атомарность проверена прямым `SELECT count(*)` в тесте.
|
||||
- Логин — выборка пользователя, проверка пароля константным по времени сравнением (`crypto/subtle`), создание записи сессии.
|
||||
- Logout — помечает сессию отозванной (`revoked_at`) и инвалидирует кэш (`del`), если Redis доступен.
|
||||
|
||||
**Что перенесено из лабы 1 без изменений:** REST-контракт `chats`/`messages` (создание, листинг, keyset-пагинация `(created_at, id)`), вся валидация JSON/UTF-8/регистра полей (`httpx.go`), `/health/live`+`/health/ready`, graceful shutdown, multi-stage `Dockerfile` (`golang:...-alpine` → `scratch`).
|
||||
|
||||
**Что изменено в этой лабе:** in-memory `Store` → PostgreSQL (`database/sql` + `lib/pq`, пул с таймаутами и лимитами соединений); `X-User-Id` полностью убран (с лабы 2 он игнорируется, не даёт доступа ни к чему) → сессии через `POST /auth/sessions` (HTTP Basic → Bearer) и `DELETE /auth/sessions/current`; пароли — Argon2id (не bcrypt: он молча режет пароли длиннее 72 байт, а контракт разрешает до 128 code points, что при многобайтных символах легко превышает 72 байта; не SHA-256/plaintext); добавлен Redis-кэш сессий с деградацией до прямого чтения Postgres при недоступности кэша.
|
||||
|
||||
**Соответствие `.env.example` реальной конфигурации:** `APP_HOST`, `APP_PORT`, `APP_ENV`, `SESSION_TTL_SECONDS`, `DATABASE_URL_FILE`, `CACHE_URL_FILE` читаются в `main.go` (`env()`/`secret()`) ровно под этими именами — без переименований. `SESSION_STORE=postgres` в шаблоне — документационная подсказка курса (сам курс отмечает: "logical interface suggestions; map actual framework names in REPORT.md"), в коде не читается: явно зафиксировано здесь, что источник истины для сессий — всегда PostgreSQL, Redis — только кэш над ним.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke (уровень 3) | `make test` | TODO — прогнать на своей машине после `docker compose up` (здесь не прогонялось: в среде разработки нет доступа к Docker Hub) | — |
|
||||
| Схема/индексы спроектированы до запросов | — | Все таблицы, constraint'ы, индексы и транзакционные границы описаны и обоснованы заранее | `db/README.md` |
|
||||
| PostgreSQL вместо in-memory, параметризованные запросы, пул соединений с таймаутами | — | Все запросы через `$N`-параметры (`lib/pq`); `SetMaxOpenConns`/`SetMaxIdleConns`/`SetConnMaxLifetime`; `context.WithTimeout` на каждый вызов; `go vet`/`gofmt -l` чисто | `src/db.go`, `src/store.go` |
|
||||
| Пароли — библиотечный KDF, не SHA-256/plaintext | — | Argon2id, самоописывающийся формат хэша (`$argon2id$v=...$m=...,t=...,p=...$salt$hash`), `crypto/subtle.ConstantTimeCompare` при проверке | `src/auth.go` |
|
||||
| Сессии: Basic-логин → Bearer, logout, TTL из `SESSION_TTL_SECONDS` | `go test -race -count=1 ./...` → `ok messenger 41.458s` | Покрыто тестами входа/выхода/истечения/неверного пароля | `src/api_test.go` |
|
||||
| Redis как кэш сессий (уровень 4) | `go test` | `TestSessionCacheHitMatchesDatabase`, `TestSessionCacheInvalidatedOnLogout` — пройдены | `src/api_test.go`, `src/cache.go` |
|
||||
| Устойчивость к падению Redis (уровень 4) | `go test` | `TestSessionValidationSurvivesRedisOutage` — действительная сессия продолжает проверяться напрямую в Postgres, Redis-ошибка никогда не трактуется как «сессия валидна» | `src/api_test.go` |
|
||||
| Устойчивость к падению Postgres | `go test` | `TestReadyAndAuthReturnUnavailableWhenPostgresDown` — `/health/ready` и защищённые endpoint отдают `503`, а не ложный `200`/анонимный доступ | `src/api_test.go` |
|
||||
| Race на регистрацию username (уровень 4) | `go test -race` | 10 конкурентных регистраций одного username → ровно одна `201`, остальные `409` (защита на `UNIQUE INDEX`, не app-level) | `src/api_test.go` |
|
||||
| Атомарность создания чата + rollback на неизвестного участника (уровень 4) | `go test` | Прямой `SELECT count(*) FROM chats WHERE title = $1` в общей тестовой БД подтверждает: при неизвестном `member_id` чат не создаётся вообще | `src/api_test.go` |
|
||||
| Индекс истории обоснован запросом + `EXPLAIN (ANALYZE, BUFFERS)` на ≥10 000 сообщениях (уровень 4) | `psql ... EXPLAIN (ANALYZE, BUFFERS)` | С индексом `messages_chat_created_idx`: `Index Scan`, 0.07–0.10 мс, 3–5 буферных чтений. Без индекса (контрольный замер, индекс восстановлен после): `Seq Scan`+`Sort`, 2.8 мс, 140 буферных чтений (~×28) | `evidence/explain_pagination.txt` |
|
||||
| Персистентность данных и валидных сессий после полного restart приложения и хранилищ | `docker compose down && docker compose up -d` (hook: `scripts/restart.sh`) | TODO — прогнать на своей машине; логика на уровне БД подтверждена (`sessions`/`messages` — обычные таблицы в volume `pgdata`, не in-memory) | — |
|
||||
| Выбранный трек 5 | — | Не заявлен | — |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Формальное нагрузочное тестирование (`make load`, RPS/p50/p95/p99/CPU/RAM под конкурентной нагрузкой) **не входит в требования уровня 4 для лабы 2** — рубрика уровня 4 здесь про корректность сессий/Postgres/Redis под конкурентностью и про обоснованность индекса, а не про пропускную способность. Поэтому вместо профиля нагрузки — таблица отказоустойчивости (это и есть «воздействия», релевантные контракту этой лабы):
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Redis недоступен (соединение рвётся/таймаут) | Валидный Bearer-токен продолжает проходить аутентификацию — деградация до прямого чтения Postgres, не `401`/`503` | Подтверждено: `TestSessionValidationSurvivesRedisOutage` | 0 — данных не теряется, теряется только ускорение от кэша |
|
||||
| PostgreSQL недоступен | `/health/ready` → `503`; защищённые endpoint → `503` (не `401`: недоступность зависимости никогда не трактуется как «анонимный запрос доверен») | Подтверждено: `TestReadyAndAuthReturnUnavailableWhenPostgresDown` | Восстановление — сразу после возврата Postgres, без ручного переинициализирования |
|
||||
| 10 параллельных регистраций одного username | Ровно одна `201`, остальные `409` | Подтверждено (race-тест, `-race` чист) | — |
|
||||
| Полный `docker compose down && up` (без `-v`) | Пользователи/чаты/сообщения/валидные сессии на месте; TTL сессии не продлён рестартом | TODO — прогнать вручную на своей машине (здесь нет доступа к Docker Hub) | TODO |
|
||||
|
||||
Условия всех прогонов: локальный PostgreSQL 16 и Redis 7, без искусственной конкурентной нагрузки на сам сервер (цель — корректность поведения при сбое зависимости, не пропускная способность). `go test -race -count=1 ./...` → `ok messenger 41.458s`, `go vet ./...` и `gofmt -l .` — чисто.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
**Выдерживается:** race на регистрацию username; атомарность создания чата с rollback; деградация при падении Redis (без ложного "valid") и при падении Postgres (503, не анонимный доступ); персистентность данных на уровне схемы (обычные таблицы в volume, не in-memory структуры).
|
||||
|
||||
**Известное осознанное ограничение:** инвалидация кэша при logout (`cache.del`) не атомарна относительно `revoked_at` в Postgres при временной недоступности Redis — отозванный токен теоретически может ещё немного отвечать из кэша как «валиден». Это не может продлить жизнь токена дольше его реального `SESSION_TTL_SECONDS` (TTL записи в кэше всегда ограничен *оставшимся* сроком жизни сессии, не фиксированным TTL), и описано здесь явно, а не скрыто.
|
||||
|
||||
**Не реализовано (вне скоупа лабы 2, ожидается в следующих лабах по контракту):** `X-Instance-Id`, `Idempotency-Key`, балансировка нескольких реплик (с лабы 3); вложения (с лабы 4); фоновая обработка (с лабы 5); HTTPS (обязателен с лабы 7).
|
||||
|
||||
**Инфраструктурное ограничение, зафиксированное сознательно:** `compose.yaml` не публикует порт PostgreSQL (`5432`) на хост — база не должна быть доступна снаружи сети compose. Это означает, что собственный набор `go test` (в отличие от публичного `make test`, которому хватает HTTP) нужно гонять либо против отдельного локального Postgres, либо временно открыв порт на время разработки — описано в разделе "Запуск из чистого clone".
|
||||
|
||||
**Что не проверено физически в среде разработки:** `docker compose up --build` и `test-persistence` — в среде, где писался код, нет сетевого доступа к Docker Hub (allowlist ограничен Go-реестрами и GitHub), поэтому сам Docker-стек не поднимался вживую. Вся логика (миграции, Postgres-store, Argon2id, Bearer-сессии, Redis-кэш) при этом проверена `go test -race` против настоящих локальных PostgreSQL 16 и Redis 7, не моков — непроверенной осталась только Docker-обёртка вокруг уже проверенной логики. Это нужно закрыть перед защитой: `docker compose up --build`, `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`.
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
# Реальная топология лабы 2 (compose.example.yaml — только воркшит ролей,
|
||||
# этот файл реализует contracts/infrastructure.json: обязательные роли
|
||||
# api+postgres (grade 3), опциональная роль redis_or_valkey обязательна
|
||||
# для grade 4 — выбран Redis.
|
||||
x-lab-number: 2
|
||||
x-required-roles:
|
||||
- api
|
||||
- postgres
|
||||
x-optional-roles-used:
|
||||
- redis_or_valkey # выбран Redis, обязателен для заявленной оценки "4"
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.4-alpine # версия зафиксирована (не latest/плавающий тег)
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
# Postgres-образ сам понимает конвенцию *_FILE — не нужен отдельный
|
||||
# entrypoint-враппер для чтения secret-файла.
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets: [postgres_password]
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data # persistent_volume: true по infrastructure.json
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.4-alpine # версия зафиксирована
|
||||
# Redis — только read-through кэш сессий (источник истины — Postgres),
|
||||
# поэтому persistence (RDB/AOF) не нужна: при потере содержимого
|
||||
# приложение просто идёт в Postgres чаще, корректность не страдает.
|
||||
# (Если решите сделать Redis источником данных, по infrastructure.json
|
||||
# нужна durable persistence — здесь это не тот случай.)
|
||||
command: ["redis-server", "--save", "", "--appendonly", "no"]
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
APP_HOST: "0.0.0.0"
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: "docker"
|
||||
SESSION_TTL_SECONDS: "3600"
|
||||
# Секреты передаются ТОЛЬКО как путь к файлу, никогда как значение в
|
||||
# command-line/обычной переменной — secret() в main.go читает именно
|
||||
# файл, на который указывает <KEY>_FILE. persistent_local_state:
|
||||
# false по infrastructure.json — у api нет собственного volume.
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
CACHE_URL_FILE: /run/secrets/cache_url
|
||||
secrets: [database_url, cache_url]
|
||||
ports:
|
||||
- "8080:8080"
|
||||
restart: unless-stopped
|
||||
# healthcheck — см. Dockerfile (HEALTHCHECK CMD ["/app/messenger", "-healthcheck"])
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password.txt
|
||||
database_url:
|
||||
file: ./secrets/database_url.txt
|
||||
cache_url:
|
||||
file: ./secrets/cache_url.txt
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,79 @@
|
||||
# Схема БД — обоснование (до запросов)
|
||||
|
||||
Таблицы и миграции лежат в `src/migrations/0001_init.{up,down}.sql`
|
||||
(embed-ятся в бинарь через `go:embed`, поэтому читать их нужно оттуда —
|
||||
здесь только обоснование решений).
|
||||
|
||||
## Таблицы
|
||||
|
||||
- **users** `(id uuid PK, username text, display_name text, password_hash
|
||||
text, created_at timestamptz)`.
|
||||
`username` уникален через `UNIQUE INDEX`, а не просто `UNIQUE`-constraint
|
||||
в тексте — Postgres всё равно реализует `UNIQUE` через индекс, явный
|
||||
индекс просто читаемее. Этот индекс — единственная защита от гонки двух
|
||||
параллельных регистраций одного username: оба INSERT идут параллельно,
|
||||
Postgres сериализует их на уровне индекса, второй получает
|
||||
`unique_violation` (SQLSTATE `23505`) → приложение превращает это в `409
|
||||
conflict`. Проверка "username свободен?" на уровне приложения перед
|
||||
INSERT не нужна и была бы лишней — она не устраняет гонку (TOCTOU), а
|
||||
только маскирует её на неудачный тест-кейс.
|
||||
`CHECK` на формат username и непустой display_name — defense in depth:
|
||||
основная валидация всё равно в Go (там читаемее текст ошибки), но даже
|
||||
если Go-код ошибётся, в БД не попадут заведомо некорректные строки.
|
||||
|
||||
- **chats** `(id uuid PK, title text, created_at timestamptz)`.
|
||||
|
||||
- **chat_members** `(chat_id uuid, user_id uuid, PK(chat_id, user_id))` —
|
||||
участники отдельной таблицей-связью, а не массивом `uuid[]` в `chats`:
|
||||
так членство проверяется через `FOREIGN KEY ... REFERENCES users(id)`
|
||||
силами БД (неизвестный участник = нарушение FK, не нужно вручную
|
||||
проверять существование каждого id в Go), а "мои чаты" читаются обычным
|
||||
`JOIN` с использованием индекса, а не разворачиванием массива.
|
||||
Отдельный индекс `(user_id, chat_id)` — потому что `user_id` не ведущий
|
||||
столбец первичного ключа `(chat_id, user_id)`, и без своего индекса
|
||||
поиск "чаты пользователя X" был бы последовательным сканом.
|
||||
|
||||
- **messages** `(id uuid PK, chat_id uuid, sender_id uuid, text text,
|
||||
created_at timestamptz)`. Индекс `(chat_id, created_at, id)` — под
|
||||
конкретный запрос keyset-пагинации истории:
|
||||
```sql
|
||||
SELECT * FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4;
|
||||
```
|
||||
Без этого индекса Postgres делает `Seq Scan` по всей таблице сообщений
|
||||
на каждый запрос страницы; с ним — `Index Scan` в диапазоне одного чата.
|
||||
`EXPLAIN (ANALYZE, BUFFERS)` на ≥10 000 строках — в `evidence/`.
|
||||
|
||||
- **sessions** `(token_hash bytea PK, user_id uuid, created_at
|
||||
timestamptz, expires_at timestamptz, revoked_at timestamptz NULL)`.
|
||||
Хранится SHA-256 от токена, а не сам токен: утечка таблицы сессий не
|
||||
даёт немедленно действующие bearer-токены (тот же принцип, что и для
|
||||
паролей — токен и так случайный с ≥256 бит энтропии, хешируем на всякий
|
||||
случай, не ради stretching). `expires_at`/`revoked_at` проверяются в
|
||||
каждом запросе; `sessions_expires_at_idx` — для будущей фоновой очистки
|
||||
истёкших строк (не обязателен для корректности логики, сама проверка
|
||||
всегда идёт по `token_hash` через PK).
|
||||
|
||||
## Транзакционные границы
|
||||
|
||||
- **Регистрация** — один `INSERT`; атомарность не обсуждается, границу
|
||||
задаёт уникальный индекс (см. выше).
|
||||
- **Создание чата** — отдельная транзакция: `INSERT chats` +
|
||||
`INSERT chat_members` (по одной строке на участника) одним
|
||||
`BEGIN…COMMIT`. Если participant неизвестен — `INSERT chat_members`
|
||||
упирается в FK-нарушение, вся транзакция откатывается целиком (ни чат,
|
||||
ни частичный список участников не остаются в БД). Явно проверено тестом
|
||||
`TestCreateChatRollsBackOnUnknownMember` — создаётся чат с одним
|
||||
существующим и одним несуществующим участником, затем убеждаемся, что
|
||||
**ни один** чат с таким title не появился в списке существующего
|
||||
участника.
|
||||
- **Отправка сообщения** — один `INSERT`; sender_id берётся из сессии, не
|
||||
из тела запроса.
|
||||
- **Вход (сессия)** — `SELECT` пользователя + проверка пароля вне
|
||||
транзакции (CPU-bound работа, держать транзакцию открытой незачем),
|
||||
затем один `INSERT sessions`.
|
||||
- **Выход** — `UPDATE sessions SET revoked_at = now()` по `token_hash`
|
||||
(плюс отдельное удаление из Redis-кэша, если он включён — см. раздел про
|
||||
кэш в REPORT.md).
|
||||
@@ -0,0 +1,108 @@
|
||||
Дата замера: 2026-10-29
|
||||
Commit: TODO (заполнить после push в форк лабы 2)
|
||||
Hardware/окружение: локальный PostgreSQL 16, 1 клиентское соединение,
|
||||
без конкурентной нагрузки (замер — EXPLAIN одного запроса, не load
|
||||
test; профиль нагрузки здесь не применим — см. REPORT.md, раздел
|
||||
"Эксперименты и отказы", про нагрузочное тестирование отдельно).
|
||||
|
||||
Условия замера: один чат (33333333-3333-4333-8333-333333333333) с
|
||||
10 000 сообщениями, вставленными с монотонно растущим created_at
|
||||
(шаг 1 микросекунда — имитация реальных последовательных INSERT).
|
||||
Запрос — ровно тот, что использует ListMessages (store.go) для
|
||||
постраничной выдачи истории чата по keyset-курсору:
|
||||
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2::timestamptz, $3::uuid)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4;
|
||||
|
||||
=== С индексом messages_chat_created_idx (как в проде) ===
|
||||
List of relations
|
||||
Schema | Name | Type | Owner | Table
|
||||
--------+---------------------------+-------+-----------+----------
|
||||
public | messages_chat_created_idx | index | messenger | messages
|
||||
(1 row)
|
||||
|
||||
QUERY PLAN
|
||||
--------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.29..4.28 rows=51 width=79) (actual time=0.022..0.034 rows=51 loops=1)
|
||||
Buffers: shared hit=3
|
||||
-> Index Scan using messages_chat_created_idx on messages (cost=0.29..782.85 rows=10000 width=79) (actual time=0.020..0.028 rows=51 loops=1)
|
||||
Index Cond: (chat_id = '33333333-3333-4333-8333-333333333333'::uuid)
|
||||
Buffers: shared hit=3
|
||||
Planning:
|
||||
Buffers: shared hit=107
|
||||
Planning Time: 0.549 ms
|
||||
Execution Time: 0.068 ms
|
||||
(9 rows)
|
||||
|
||||
|
||||
=== Страница из середины истории (keyset, courser после 5000-го сообщения) ===
|
||||
QUERY PLAN
|
||||
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.29..5.61 rows=51 width=79) (actual time=0.027..0.055 rows=51 loops=1)
|
||||
Buffers: shared hit=5
|
||||
-> Index Scan using messages_chat_created_idx on messages (cost=0.29..522.16 rows=5000 width=79) (actual time=0.026..0.048 rows=51 loops=1)
|
||||
Index Cond: ((chat_id = '33333333-3333-4333-8333-333333333333'::uuid) AND (ROW(created_at, id) > ROW('2026-10-29 10:40:13.145502+00'::timestamp with time zone, '96662338-d68a-4b47-bd34-42b9034d5eef'::uuid)))
|
||||
Buffers: shared hit=5
|
||||
Planning:
|
||||
Buffers: shared hit=106
|
||||
Planning Time: 0.534 ms
|
||||
Execution Time: 0.104 ms
|
||||
(9 rows)
|
||||
|
||||
|
||||
=== Контрольный замер: БЕЗ индекса messages_chat_created_idx ===
|
||||
(индекс временно удалён только для этого замера и сразу восстановлен ниже)
|
||||
DROP INDEX
|
||||
QUERY PLAN
|
||||
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=475.81..475.94 rows=51 width=79) (actual time=2.781..2.791 rows=51 loops=1)
|
||||
Buffers: shared hit=140
|
||||
-> Sort (cost=475.81..488.31 rows=5000 width=79) (actual time=2.780..2.784 rows=51 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 31kB
|
||||
Buffers: shared hit=140
|
||||
-> Seq Scan on messages (cost=0.00..309.00 rows=5000 width=79) (actual time=0.999..1.824 rows=5000 loops=1)
|
||||
Filter: ((chat_id = '33333333-3333-4333-8333-333333333333'::uuid) AND (ROW(created_at, id) > ROW('2026-10-29 10:40:13.145502+00'::timestamp with time zone, '96662338-d68a-4b47-bd34-42b9034d5eef'::uuid)))
|
||||
Rows Removed by Filter: 5000
|
||||
Buffers: shared hit=134
|
||||
Planning:
|
||||
Buffers: shared hit=79 dirtied=1
|
||||
Planning Time: 0.579 ms
|
||||
Execution Time: 2.829 ms
|
||||
(14 rows)
|
||||
|
||||
CREATE INDEX
|
||||
|
||||
=== Индекс восстановлен; повторная проверка ===
|
||||
List of relations
|
||||
Schema | Name | Type | Owner | Table
|
||||
--------+---------------------------+-------+-----------+----------
|
||||
public | messages_chat_created_idx | index | messenger | messages
|
||||
(1 row)
|
||||
|
||||
=== Вывод ===
|
||||
С индексом (chat_id, created_at, id): Index Scan, 3-5 shared buffer
|
||||
hits, Execution Time 0.07-0.10 ms, план не зависит от позиции курсора
|
||||
в истории (одинаково быстро и на первой странице, и после 5000-го
|
||||
сообщения) — классическое поведение B-tree по составному ключу.
|
||||
|
||||
Без индекса: планировщик вынужден читать ВСЮ историю чата (Seq Scan,
|
||||
5000 строк прочитано и отфильтровано только для того, чтобы отбросить
|
||||
их все) и сортировать результат в памяти (Sort/top-N heapsort) перед
|
||||
тем как отдать 51 строку. 140 shared buffer hits и 2.8 ms на 10 000
|
||||
строк — почти в 30 раз больше буферных чтений и почти в 30 раз
|
||||
дольше, чем с индексом, и это на единственном чате из одного лаба;
|
||||
при реальной нагрузке (много чатов, десятки тысяч сообщений в каждом,
|
||||
постоянная пагинация) full-scan-подход деградировал бы линейно с
|
||||
размером истории чата, а не константно, как Index Scan.
|
||||
|
||||
Поэтому ListMessages в store.go не делает full scan всей истории на
|
||||
каждую страницу: именно составной индекс messages_chat_created_idx
|
||||
(chat_id, created_at, id), созданный в migrations/0001_init.up.sql,
|
||||
и делает keyset-пагинацию (WHERE chat_id = $1 AND (created_at, id) >
|
||||
($cursor_ts, $cursor_id) ORDER BY created_at, id LIMIT $n) дешёвой
|
||||
независимо от того, насколько длинная история чата и на какой
|
||||
странице стоит курсор.
|
||||
|
||||
Executable
+25
@@ -0,0 +1,25 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Реализация restart.example.sh для docker-compose.yml из этой лабы.
|
||||
#
|
||||
# "down" без "-v" удаляет КОНТЕЙНЕРЫ api/postgres/redis, но не трогает
|
||||
# именованный volume pgdata — поэтому после "up" Postgres поднимается
|
||||
# с тем же содержимым data-директории, а не с чистой. Это и есть
|
||||
# "полный restart приложения и ВСЕХ используемых хранилищ": процессы
|
||||
# действительно уничтожаются и создаются заново (а не просто получают
|
||||
# SIGHUP), но persistent-данные переживают это за счёт volume, а не за
|
||||
# счёт того, что сам процесс не перезапускался.
|
||||
#
|
||||
# Redis explicitly без persistence (--save "" --appendonly no, см.
|
||||
# docker-compose.yml) — это осознанно: Redis здесь только read-through
|
||||
# кэш сессий, источник истины — Postgres. Потеря кэша при restart не
|
||||
# нарушает корректность, только чуть замедляет первые запросы после
|
||||
# рестарта (кэш холодный, идём в Postgres).
|
||||
#
|
||||
# Никаких "down -v", "flush" или ре-сидинга — ровно то, что требует
|
||||
# restart.example.sh.
|
||||
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
docker compose down
|
||||
docker compose up -d
|
||||
+873
@@ -0,0 +1,873 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"os"
|
||||
"runtime"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// TestMain: один раз поднимает соединение к ТЕСТОВОЙ PostgreSQL (TEST_DATABASE_URL
|
||||
// или локальный дефолт) и прогоняет миграции. Каждый newTestEnv(t) затем
|
||||
// усекает все таблицы — тесты запускаются последовательно (без t.Parallel),
|
||||
// так что усечение в начале теста даёт чистый лист без гонок между тестами.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
var sharedDB *pgxpool.Pool
|
||||
|
||||
func TestMain(m *testing.M) {
|
||||
dsn := os.Getenv("TEST_DATABASE_URL")
|
||||
if dsn == "" {
|
||||
dsn = "postgres://messenger:messenger@localhost:5432/messenger?sslmode=disable"
|
||||
}
|
||||
if err := runMigrations(dsn); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "миграции для тестовой БД:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
db, err := openPool(ctx, dsn)
|
||||
cancel()
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "нужен запущенный Postgres для тестов (TEST_DATABASE_URL):", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
sharedDB = db
|
||||
code := m.Run()
|
||||
db.Close()
|
||||
os.Exit(code)
|
||||
}
|
||||
|
||||
func truncateAll(t *testing.T) {
|
||||
t.Helper()
|
||||
if _, err := sharedDB.Exec(context.Background(),
|
||||
`TRUNCATE sessions, messages, chat_members, chats, users CASCADE`); err != nil {
|
||||
t.Fatalf("truncate: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// testEnv: тесты ходят в настоящий HTTP-сервер (httptest) с тем же роутером,
|
||||
// что и в проде, поэтому проверяется весь путь запроса.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
type testEnv struct {
|
||||
t *testing.T
|
||||
url string
|
||||
}
|
||||
|
||||
func newTestEnv(t *testing.T) *testEnv {
|
||||
return newTestEnvTTL(t, time.Hour)
|
||||
}
|
||||
|
||||
func newTestEnvTTL(t *testing.T, ttl time.Duration) *testEnv {
|
||||
t.Helper()
|
||||
truncateAll(t)
|
||||
srv := httptest.NewServer((&api{store: NewStore(sharedDB, nil, ttl)}).routes())
|
||||
t.Cleanup(srv.Close)
|
||||
return &testEnv{t: t, url: srv.URL}
|
||||
}
|
||||
|
||||
// newTestEnvWithCache поднимает тот же роутер, но с реальным Redis-кэшем
|
||||
// сессий поверх той же PostgreSQL — для тестов, специфичных для кэша
|
||||
// (попадание в кэш, инвалидация при logout, деградация при отказе Redis).
|
||||
func newTestEnvWithCache(t *testing.T) *testEnv {
|
||||
t.Helper()
|
||||
truncateAll(t)
|
||||
addr := os.Getenv("TEST_CACHE_URL")
|
||||
if addr == "" {
|
||||
addr = "redis://localhost:6379/0"
|
||||
}
|
||||
cache, err := newSessionCache(addr)
|
||||
if err != nil {
|
||||
t.Fatalf("нужен запущенный Redis для теста (TEST_CACHE_URL): %v", err)
|
||||
}
|
||||
if err := cache.rdb.FlushDB(context.Background()).Err(); err != nil {
|
||||
t.Fatalf("flushdb: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { cache.Close() })
|
||||
srv := httptest.NewServer((&api{store: NewStore(sharedDB, cache, time.Hour)}).routes())
|
||||
t.Cleanup(srv.Close)
|
||||
return &testEnv{t: t, url: srv.URL}
|
||||
}
|
||||
|
||||
type page[T any] struct {
|
||||
Items []T `json:"items"`
|
||||
NextCursor *string `json:"next_cursor"`
|
||||
}
|
||||
|
||||
// send безопасен для вызова из горутин (не трогает *testing.T).
|
||||
// token: "" — без Bearer-авторизации. extra — дополнительные/замещающие
|
||||
// заголовки (например Authorization: Basic для входа).
|
||||
// body: nil — без тела; []byte/string — «как есть» (для битого JSON); остальное — JSON.
|
||||
func (e *testEnv) send(method, path, token string, body any, extra http.Header) (int, http.Header, []byte, error) {
|
||||
var rd io.Reader
|
||||
switch b := body.(type) {
|
||||
case nil:
|
||||
case []byte:
|
||||
rd = bytes.NewReader(b)
|
||||
case string:
|
||||
rd = strings.NewReader(b)
|
||||
default:
|
||||
raw, err := json.Marshal(b)
|
||||
if err != nil {
|
||||
return 0, nil, nil, err
|
||||
}
|
||||
rd = bytes.NewReader(raw)
|
||||
}
|
||||
req, err := http.NewRequest(method, e.url+path, rd)
|
||||
if err != nil {
|
||||
return 0, nil, nil, err
|
||||
}
|
||||
if rd != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
for k, vs := range extra {
|
||||
req.Header.Del(k) // extra заменяет дефолт (например, свой Content-Type), а не дублирует
|
||||
for _, v := range vs {
|
||||
req.Header.Add(k, v)
|
||||
}
|
||||
}
|
||||
if token != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+token)
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
return 0, nil, nil, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
data, err := io.ReadAll(resp.Body)
|
||||
return resp.StatusCode, resp.Header, data, err
|
||||
}
|
||||
|
||||
func (e *testEnv) do(method, path, token string, body any) (int, http.Header, []byte) {
|
||||
e.t.Helper()
|
||||
status, hdr, data, err := e.send(method, path, token, body, nil)
|
||||
if err != nil {
|
||||
e.t.Fatalf("%s %s: %v", method, path, err)
|
||||
}
|
||||
return status, hdr, data
|
||||
}
|
||||
|
||||
func basicAuthHeader(username, password string) http.Header {
|
||||
cred := base64.StdEncoding.EncodeToString([]byte(username + ":" + password))
|
||||
return http.Header{"Authorization": []string{"Basic " + cred}}
|
||||
}
|
||||
|
||||
// expectJSON проверяет код ответа и разбирает тело в dst.
|
||||
func (e *testEnv) expectJSON(status int, dst any, method, path, token string, body any) {
|
||||
e.t.Helper()
|
||||
got, _, data := e.do(method, path, token, body)
|
||||
if got != status {
|
||||
e.t.Fatalf("%s %s: статус %d, ожидали %d; тело: %s", method, path, got, status, data)
|
||||
}
|
||||
if dst != nil {
|
||||
if err := json.Unmarshal(data, dst); err != nil {
|
||||
e.t.Fatalf("%s %s: некорректный JSON в ответе: %v", method, path, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// expectErr проверяет код, машинный код ошибки и что request_id в теле == X-Request-Id.
|
||||
func (e *testEnv) expectErr(status int, code, method, path, token string, body any) {
|
||||
e.t.Helper()
|
||||
got, hdr, data := e.do(method, path, token, body)
|
||||
if got != status {
|
||||
e.t.Fatalf("%s %s: статус %d, ожидали %d; тело: %s", method, path, got, status, data)
|
||||
}
|
||||
var env struct {
|
||||
Error struct {
|
||||
Code string `json:"code"`
|
||||
Message string `json:"message"`
|
||||
RequestID string `json:"request_id"`
|
||||
} `json:"error"`
|
||||
}
|
||||
if err := json.Unmarshal(data, &env); err != nil {
|
||||
e.t.Fatalf("%s %s: тело ошибки не JSON: %s", method, path, data)
|
||||
}
|
||||
rid := hdr.Get("X-Request-Id")
|
||||
if rid == "" || env.Error.RequestID != rid {
|
||||
e.t.Fatalf("%s %s: request_id в теле (%q) не совпадает с заголовком (%q)", method, path, env.Error.RequestID, rid)
|
||||
}
|
||||
if env.Error.Code != code || env.Error.Message == "" {
|
||||
e.t.Fatalf("%s %s: код ошибки %q, ожидали %q", method, path, env.Error.Code, code)
|
||||
}
|
||||
}
|
||||
|
||||
// actor — зарегистрированный и вошедший пользователь: и сам User, и
|
||||
// Bearer-токен его сессии, и исходный пароль (для повторного логина в тестах).
|
||||
type actor struct {
|
||||
user User
|
||||
password string
|
||||
token string
|
||||
}
|
||||
|
||||
func (e *testEnv) mustRegister(username string) User {
|
||||
e.t.Helper()
|
||||
var u User
|
||||
e.expectJSON(http.StatusCreated, &u, "POST", "/api/v1/users", "",
|
||||
map[string]string{"username": username, "display_name": "Тест " + username, "password": "Correct-horse-battery-staple"})
|
||||
return u
|
||||
}
|
||||
|
||||
// mustActor регистрирует и один раз логинится — основной способ получить
|
||||
// рабочего "актёра" для теста.
|
||||
func (e *testEnv) mustActor(username string) actor {
|
||||
e.t.Helper()
|
||||
const password = "Correct-horse-battery-staple"
|
||||
u := e.mustRegister(username)
|
||||
return e.loginActor(u, password)
|
||||
}
|
||||
|
||||
func (e *testEnv) loginActor(u User, password string) actor {
|
||||
e.t.Helper()
|
||||
status, _, data, err := e.send("POST", "/api/v1/auth/sessions", "", nil, basicAuthHeader(u.Username, password))
|
||||
if err != nil {
|
||||
e.t.Fatalf("login: %v", err)
|
||||
}
|
||||
if status != http.StatusCreated {
|
||||
e.t.Fatalf("login %s: статус %d, тело: %s", u.Username, status, data)
|
||||
}
|
||||
var s Session
|
||||
if err := json.Unmarshal(data, &s); err != nil {
|
||||
e.t.Fatalf("login %s: некорректный JSON: %v", u.Username, err)
|
||||
}
|
||||
return actor{user: u, password: password, token: s.Token}
|
||||
}
|
||||
|
||||
func (e *testEnv) mustChat(owner actor, title string, members ...actor) Chat {
|
||||
e.t.Helper()
|
||||
ids := []string{owner.user.ID}
|
||||
for _, m := range members {
|
||||
ids = append(ids, m.user.ID)
|
||||
}
|
||||
var c Chat
|
||||
e.expectJSON(http.StatusCreated, &c, "POST", "/api/v1/chats", owner.token,
|
||||
map[string]any{"title": title, "member_ids": ids})
|
||||
return c
|
||||
}
|
||||
|
||||
func (e *testEnv) mustMessage(a actor, chatID, text string) Message {
|
||||
e.t.Helper()
|
||||
var m Message
|
||||
e.expectJSON(http.StatusCreated, &m, "POST", "/api/v1/chats/"+chatID+"/messages", a.token,
|
||||
map[string]string{"text": text})
|
||||
return m
|
||||
}
|
||||
|
||||
// listMessages обходит всю историю страницами по limit и возвращает все элементы и число страниц.
|
||||
func (e *testEnv) listMessages(a actor, chatID string, limit int) ([]Message, int) {
|
||||
e.t.Helper()
|
||||
var all []Message
|
||||
cursor, pages := "", 0
|
||||
for {
|
||||
if pages++; pages > 1000 {
|
||||
e.t.Fatal("пагинация не завершается")
|
||||
}
|
||||
path := fmt.Sprintf("/api/v1/chats/%s/messages?limit=%d", chatID, limit)
|
||||
if cursor != "" {
|
||||
path += "&cursor=" + url.QueryEscape(cursor)
|
||||
}
|
||||
var p page[Message]
|
||||
e.expectJSON(http.StatusOK, &p, "GET", path, a.token, nil)
|
||||
if len(p.Items) > limit {
|
||||
e.t.Fatalf("на странице %d элементов при limit=%d", len(p.Items), limit)
|
||||
}
|
||||
all = append(all, p.Items...)
|
||||
if p.NextCursor == nil {
|
||||
return all, pages
|
||||
}
|
||||
cursor = *p.NextCursor
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Тесты
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
func TestRegisterUserInvalidInput(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
validPW := "Correct-horse-battery-staple"
|
||||
cases := map[string]any{
|
||||
"битый JSON": `{"username":`,
|
||||
"мусор после объекта": `{"username":"abc","display_name":"x","password":"` + validPW + `"} {}`,
|
||||
"null вместо объекта": `null`,
|
||||
"лишнее поле": map[string]any{"username": "abc", "display_name": "x", "password": validPW, "admin": true},
|
||||
"неверный тип": `{"username":"abc","display_name":5,"password":"` + validPW + `"}`,
|
||||
"нет password": map[string]string{"username": "abc", "display_name": "x"},
|
||||
"username верхний регистр": map[string]string{"username": "Alice", "display_name": "x", "password": validPW},
|
||||
"username короче 3": map[string]string{"username": "ab", "display_name": "x", "password": validPW},
|
||||
"username длиннее 32": map[string]string{"username": strings.Repeat("a", 33), "display_name": "x", "password": validPW},
|
||||
"username с дефисом": map[string]string{"username": "al-ice", "display_name": "x", "password": validPW},
|
||||
"display_name пробелы": map[string]string{"username": "abc", "display_name": " ", "password": validPW},
|
||||
"display_name 101": map[string]string{"username": "abc", "display_name": strings.Repeat("я", 101), "password": validPW},
|
||||
"password короче 12": map[string]string{"username": "abc", "display_name": "x", "password": "short-pass"},
|
||||
"password длиннее 128": map[string]string{"username": "abc", "display_name": "x", "password": strings.Repeat("a", 129)},
|
||||
"password из пробелов": map[string]string{"username": "abc", "display_name": "x", "password": strings.Repeat(" ", 20)},
|
||||
}
|
||||
for name, body := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "POST", "/api/v1/users", "", body)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegisterUserWrongContentType(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
got, _, data, err := e.send("POST", "/api/v1/users", "", []byte(`not json`), http.Header{"Content-Type": {"text/plain"}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got != http.StatusUnsupportedMediaType {
|
||||
t.Fatalf("статус %d, тело %s", got, data)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDuplicateUsername(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
e.mustRegister("alice")
|
||||
e.expectErr(http.StatusConflict, "conflict", "POST", "/api/v1/users", "",
|
||||
map[string]string{"username": "alice", "display_name": "Другая Алиса", "password": "Correct-horse-battery-staple"})
|
||||
}
|
||||
|
||||
// Гонка двух параллельных регистраций ОДНОГО username: ровно один 201,
|
||||
// ровно один 409 — защита идёт через UNIQUE INDEX в PostgreSQL, не через
|
||||
// check-then-insert в Go (который был бы подвержен той же гонке).
|
||||
func TestConcurrentRegistrationSameUsernameOnlyOneSucceeds(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
const n = 10
|
||||
var wg sync.WaitGroup
|
||||
statuses := make([]int, n)
|
||||
for i := 0; i < n; i++ {
|
||||
wg.Add(1)
|
||||
go func(i int) {
|
||||
defer wg.Done()
|
||||
status, _, _ := e.do("POST", "/api/v1/users", "",
|
||||
map[string]string{"username": "racer", "display_name": "Racer", "password": "Correct-horse-battery-staple"})
|
||||
statuses[i] = status
|
||||
}(i)
|
||||
}
|
||||
wg.Wait()
|
||||
created, conflicted := 0, 0
|
||||
for _, s := range statuses {
|
||||
switch s {
|
||||
case http.StatusCreated:
|
||||
created++
|
||||
case http.StatusConflict:
|
||||
conflicted++
|
||||
default:
|
||||
t.Fatalf("неожиданный статус %d", s)
|
||||
}
|
||||
}
|
||||
if created != 1 || conflicted != n-1 {
|
||||
t.Fatalf("created=%d conflicted=%d, ожидали 1 и %d", created, conflicted, n-1)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoginWrongCredentials(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
u := e.mustRegister("alice")
|
||||
status, hdr, _, err := e.send("POST", "/api/v1/auth/sessions", "", nil, basicAuthHeader(u.Username, "wrong-password-but-long-enough"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("статус %d, ожидали 401", status)
|
||||
}
|
||||
if !strings.HasPrefix(strings.ToLower(hdr.Get("WWW-Authenticate")), "basic") {
|
||||
t.Fatalf("WWW-Authenticate=%q, ожидали Basic", hdr.Get("WWW-Authenticate"))
|
||||
}
|
||||
|
||||
status2, _, _, _ := e.send("POST", "/api/v1/auth/sessions", "", nil, basicAuthHeader("no-such-user", "whatever-long-enough"))
|
||||
if status2 != http.StatusUnauthorized {
|
||||
t.Fatalf("неизвестный username: статус %d, ожидали 401", status2)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnauthorized(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/users/me", "", nil)
|
||||
e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/users/me", "not-a-real-token", nil)
|
||||
}
|
||||
|
||||
// Basic на бизнес-endpoint — 401 (там нужен именно Bearer).
|
||||
func TestBasicOnBusinessEndpointRejected(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
u := e.mustRegister("alice")
|
||||
status, _, _, err := e.send("GET", "/api/v1/users/me", "", nil, basicAuthHeader(u.Username, "Correct-horse-battery-staple"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("статус %d, ожидали 401", status)
|
||||
}
|
||||
}
|
||||
|
||||
// X-User-Id с lab2 ничего не даёт сам по себе и не переопределяет личность
|
||||
// из Bearer-токена.
|
||||
func TestXUserIdHeaderIgnored(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
eve := e.mustActor("eve")
|
||||
|
||||
status, _, _, err := e.send("GET", "/api/v1/users/me", "", nil, http.Header{"X-User-Id": {eve.user.ID}})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("X-User-Id без Bearer: статус %d, ожидали 401", status)
|
||||
}
|
||||
|
||||
status2, _, data2, err := e.send("GET", "/api/v1/users/me", "", nil, http.Header{
|
||||
"Authorization": {"Bearer " + alice.token},
|
||||
"X-User-Id": {eve.user.ID},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if status2 != http.StatusOK {
|
||||
t.Fatalf("статус %d", status2)
|
||||
}
|
||||
var me2 User
|
||||
if err := json.Unmarshal(data2, &me2); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if me2.ID != alice.user.ID {
|
||||
t.Fatalf("X-User-Id переопределил личность из Bearer: получили %s, ожидали %s", me2.ID, alice.user.ID)
|
||||
}
|
||||
}
|
||||
|
||||
// Logout отзывает токен; повторный logout тем же токеном — 401 (он уже недействителен).
|
||||
func TestSessionLogout(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
|
||||
status, _, _ := e.do("DELETE", "/api/v1/auth/sessions/current", alice.token, nil)
|
||||
if status != http.StatusNoContent {
|
||||
t.Fatalf("logout: статус %d, ожидали 204", status)
|
||||
}
|
||||
e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/users/me", alice.token, nil)
|
||||
e.expectErr(http.StatusUnauthorized, "unauthorized", "DELETE", "/api/v1/auth/sessions/current", alice.token, nil)
|
||||
}
|
||||
|
||||
// Короткий TTL — явная автоматическая проверка истечения сессии.
|
||||
func TestSessionExpiry(t *testing.T) {
|
||||
e := newTestEnvTTL(t, 1*time.Second)
|
||||
alice := e.mustActor("alice")
|
||||
var me User
|
||||
e.expectJSON(http.StatusOK, &me, "GET", "/api/v1/users/me", alice.token, nil)
|
||||
time.Sleep(1200 * time.Millisecond)
|
||||
e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/users/me", alice.token, nil)
|
||||
}
|
||||
|
||||
func TestOutsiderCannotAccessChat(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
bob := e.mustActor("bob")
|
||||
eve := e.mustActor("eve")
|
||||
chat := e.mustChat(alice, "чат", bob)
|
||||
|
||||
e.expectErr(http.StatusNotFound, "not_found", "GET", "/api/v1/chats/"+chat.ID, eve.token, nil)
|
||||
e.expectErr(http.StatusNotFound, "not_found", "POST", "/api/v1/chats/"+chat.ID+"/messages", eve.token,
|
||||
map[string]string{"text": "чужое"})
|
||||
e.expectErr(http.StatusNotFound, "not_found", "GET", "/api/v1/chats/"+chat.ID+"/messages", eve.token, nil)
|
||||
|
||||
var listed page[Chat]
|
||||
e.expectJSON(http.StatusOK, &listed, "GET", "/api/v1/chats?limit=100", eve.token, nil)
|
||||
for _, c := range listed.Items {
|
||||
if c.ID == chat.ID {
|
||||
t.Fatal("чужой чат утёк в список чатов постороннего")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateChatValidation(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
bob := e.mustActor("bob")
|
||||
cases := map[string]map[string]any{
|
||||
"пустой title": {"title": "", "member_ids": []string{alice.user.ID}},
|
||||
"пустой список": {"title": "x", "member_ids": []string{}},
|
||||
"не UUID в member_ids": {"title": "x", "member_ids": []string{"not-a-uuid"}},
|
||||
"дубликаты участников": {"title": "x", "member_ids": []string{alice.user.ID, alice.user.ID}},
|
||||
"вызывающий не в списке": {"title": "x", "member_ids": []string{bob.user.ID}},
|
||||
"неизвестный участник": {"title": "x", "member_ids": []string{alice.user.ID, newUUID()}},
|
||||
}
|
||||
for name, body := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "POST", "/api/v1/chats", alice.token, body)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Составная операция создания чата атомарна: неизвестный участник не
|
||||
// должен оставить после себя ни чат, ни частичный список участников.
|
||||
func TestCreateChatRollsBackOnUnknownMember(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
const title = "Чат с несуществующим участником"
|
||||
|
||||
status, _, data := e.do("POST", "/api/v1/chats", alice.token,
|
||||
map[string]any{"title": title, "member_ids": []string{alice.user.ID, newUUID()}})
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("статус %d, тело %s", status, data)
|
||||
}
|
||||
|
||||
var listed page[Chat]
|
||||
e.expectJSON(http.StatusOK, &listed, "GET", "/api/v1/chats?limit=100", alice.token, nil)
|
||||
for _, c := range listed.Items {
|
||||
if c.Title == title {
|
||||
t.Fatalf("откат не сработал: чат %q всё равно появился в списке", title)
|
||||
}
|
||||
}
|
||||
|
||||
var count int
|
||||
if err := sharedDB.QueryRow(context.Background(),
|
||||
`SELECT count(*) FROM chats WHERE title = $1`, title).Scan(&count); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if count != 0 {
|
||||
t.Fatalf("в БД осталась %d строк(а) чата, который должен был откатиться", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageValidation(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
chat := e.mustChat(alice, "чат")
|
||||
cases := map[string]any{
|
||||
"пустой текст": map[string]string{"text": ""},
|
||||
"только пробелы": map[string]string{"text": " "},
|
||||
"нет поля text": map[string]string{},
|
||||
"text не строка": `{"text":5}`,
|
||||
"4001 code point": map[string]string{"text": strings.Repeat("я", 4001)},
|
||||
"sender_id в теле": map[string]any{"text": "привет", "sender_id": newUUID()},
|
||||
"лишнее поле": map[string]any{"text": "привет", "extra": true},
|
||||
"битый JSON": `{"text":`,
|
||||
"два объекта подряд": `{"text":"a"} {}`,
|
||||
}
|
||||
for name, body := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "POST",
|
||||
"/api/v1/chats/"+chat.ID+"/messages", alice.token, body)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPaginationWalksAllPages(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
chat := e.mustChat(alice, "чат")
|
||||
const total = 53
|
||||
for i := 0; i < total; i++ {
|
||||
e.mustMessage(alice, chat.ID, fmt.Sprint(i))
|
||||
}
|
||||
for _, limit := range []int{1, 7, 24, 25, 100} {
|
||||
t.Run(fmt.Sprintf("limit=%d", limit), func(t *testing.T) {
|
||||
items, _ := e.listMessages(alice, chat.ID, limit)
|
||||
if len(items) != total {
|
||||
t.Fatalf("получили %d сообщений, ожидали %d", len(items), total)
|
||||
}
|
||||
for i, m := range items {
|
||||
if m.Text != fmt.Sprint(i) {
|
||||
t.Fatalf("сообщение %d: текст %q, ожидали %q (порядок нарушен)", i, m.Text, fmt.Sprint(i))
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPaginationBadParameters(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
chat := e.mustChat(alice, "чат")
|
||||
other := e.mustActor("bob")
|
||||
otherChat := e.mustChat(other, "другой чат")
|
||||
e.mustMessage(alice, chat.ID, "привет")
|
||||
|
||||
cases := map[string]string{
|
||||
"limit=0": "?limit=0",
|
||||
"limit=101": "?limit=101",
|
||||
"limit=-1": "?limit=-1",
|
||||
"limit=abc": "?limit=abc",
|
||||
"cursor мусор": "?cursor=not-a-valid-cursor",
|
||||
}
|
||||
for name, q := range cases {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "GET",
|
||||
"/api/v1/chats/"+chat.ID+"/messages"+q, alice.token, nil)
|
||||
})
|
||||
}
|
||||
|
||||
// Курсор чужого (другого) scope — тоже 400.
|
||||
var p page[Message]
|
||||
e.expectJSON(http.StatusOK, &p, "GET", "/api/v1/chats/"+otherChat.ID+"/messages?limit=1", other.token, nil)
|
||||
foreignCursor := encodeCursor("m:"+chat.ID, "2024-01-01T00:00:00.000000Z", newUUID())
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "GET",
|
||||
"/api/v1/chats/"+otherChat.ID+"/messages?cursor="+url.QueryEscape(foreignCursor), other.token, nil)
|
||||
}
|
||||
|
||||
func TestChatListPagination(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
const total = 12
|
||||
seen := map[string]bool{}
|
||||
for i := 0; i < total; i++ {
|
||||
e.mustChat(alice, fmt.Sprintf("чат %d", i))
|
||||
}
|
||||
cursor := ""
|
||||
for {
|
||||
path := "/api/v1/chats?limit=5"
|
||||
if cursor != "" {
|
||||
path += "&cursor=" + url.QueryEscape(cursor)
|
||||
}
|
||||
var p page[Chat]
|
||||
e.expectJSON(http.StatusOK, &p, "GET", path, alice.token, nil)
|
||||
for _, c := range p.Items {
|
||||
if seen[c.ID] {
|
||||
t.Fatalf("чат %s отдан дважды", c.ID)
|
||||
}
|
||||
seen[c.ID] = true
|
||||
}
|
||||
if p.NextCursor == nil {
|
||||
break
|
||||
}
|
||||
cursor = *p.NextCursor
|
||||
}
|
||||
if len(seen) != total {
|
||||
t.Fatalf("получили %d чатов, ожидали %d", len(seen), total)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEveryResponseHasRequestID(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
_, hdr, _ := e.do("GET", "/health/live", "", nil)
|
||||
if hdr.Get("X-Request-Id") == "" {
|
||||
t.Fatal("health/live без X-Request-Id")
|
||||
}
|
||||
_, hdr2, _ := e.do("GET", "/api/v1/users/me", "", nil)
|
||||
if hdr2.Get("X-Request-Id") == "" {
|
||||
t.Fatal("ошибка 401 без X-Request-Id")
|
||||
}
|
||||
}
|
||||
|
||||
// 100 сообщений от 10 параллельных клиентов -> ровно 100 уникальных сообщений.
|
||||
func TestConcurrentSendKeepsEveryMessage(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
chat := e.mustChat(alice, "чат")
|
||||
const writers, perWriter = 10, 10
|
||||
var wg sync.WaitGroup
|
||||
for w := 0; w < writers; w++ {
|
||||
wg.Add(1)
|
||||
go func(w int) {
|
||||
defer wg.Done()
|
||||
for i := 0; i < perWriter; i++ {
|
||||
status, _, data := e.do("POST", "/api/v1/chats/"+chat.ID+"/messages", alice.token,
|
||||
map[string]string{"text": fmt.Sprintf("w%d-m%d", w, i)})
|
||||
if status != http.StatusCreated {
|
||||
e.t.Errorf("писатель %d сообщение %d: статус %d, тело %s", w, i, status, data)
|
||||
}
|
||||
runtime.Gosched()
|
||||
}
|
||||
}(w)
|
||||
}
|
||||
wg.Wait()
|
||||
|
||||
items, _ := e.listMessages(alice, chat.ID, 100)
|
||||
if len(items) != writers*perWriter {
|
||||
t.Fatalf("сообщений %d, ожидали %d", len(items), writers*perWriter)
|
||||
}
|
||||
seen := make(map[string]bool, len(items))
|
||||
for _, m := range items {
|
||||
if seen[m.ID] {
|
||||
t.Fatalf("сообщение %s отдано дважды", m.ID)
|
||||
}
|
||||
seen[m.ID] = true
|
||||
}
|
||||
}
|
||||
|
||||
// Дубликат ключа, отличающегося только регистром, не должен тихо
|
||||
// перезаписывать значение правильно написанного поля.
|
||||
func TestDuplicateKeyDifferingOnlyInCaseIsRejected(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
chat := e.mustChat(alice, "чат")
|
||||
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "POST",
|
||||
"/api/v1/chats/"+chat.ID+"/messages", alice.token,
|
||||
[]byte(`{"text":"valid","TEXT":"overwritten"}`))
|
||||
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "POST",
|
||||
"/api/v1/users", "",
|
||||
[]byte(`{"username":"bob1","display_name":"Боб","DISPLAY_NAME":"Подмена","password":"Correct-horse-battery-staple"}`))
|
||||
}
|
||||
|
||||
// Невалидные байты UTF-8 должны отклоняться 400, а не тихо приниматься.
|
||||
func TestInvalidUTF8IsRejected(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
chat := e.mustChat(alice, "чат")
|
||||
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "POST",
|
||||
"/api/v1/chats/"+chat.ID+"/messages", alice.token,
|
||||
[]byte("{\"text\":\"\xff\"}"))
|
||||
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "POST",
|
||||
"/api/v1/users", "",
|
||||
[]byte("{\"username\":\"bob2\",\"display_name\":\"\xff\",\"password\":\"Correct-horse-battery-staple\"}"))
|
||||
}
|
||||
|
||||
// Структурно правильный, но семантически мусорный cursor — 400, не пустая страница.
|
||||
func TestGarbageCursorIsRejected(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
alice := e.mustActor("alice")
|
||||
chat := e.mustChat(alice, "чат")
|
||||
e.mustMessage(alice, chat.ID, "привет")
|
||||
|
||||
garbage := base64.RawURLEncoding.EncodeToString([]byte("m:" + chat.ID + "|not-a-time|not-a-uuid"))
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "GET",
|
||||
"/api/v1/chats/"+chat.ID+"/messages?cursor="+url.QueryEscape(garbage), alice.token, nil)
|
||||
|
||||
badTime := base64.RawURLEncoding.EncodeToString([]byte("c:" + alice.user.ID + "|not-a-time|" + newUUID()))
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "GET",
|
||||
"/api/v1/chats?cursor="+url.QueryEscape(badTime), alice.token, nil)
|
||||
|
||||
badUUID := base64.RawURLEncoding.EncodeToString([]byte("c:" + alice.user.ID + "|2024-01-01T00:00:00.000000Z|not-a-uuid"))
|
||||
e.expectErr(http.StatusBadRequest, "invalid_request", "GET",
|
||||
"/api/v1/chats?cursor="+url.QueryEscape(badUUID), alice.token, nil)
|
||||
}
|
||||
|
||||
// --- кэш сессий (уровень 4) ------------------------------------------------
|
||||
|
||||
// Попадание в кэш отдаёт того же пользователя, что и прямой поход в Postgres.
|
||||
func TestSessionCacheHitMatchesDatabase(t *testing.T) {
|
||||
e := newTestEnvWithCache(t)
|
||||
alice := e.mustActor("alice")
|
||||
var fromMiss User
|
||||
e.expectJSON(http.StatusOK, &fromMiss, "GET", "/api/v1/users/me", alice.token, nil) // первый — промах, заполняет кэш
|
||||
var fromHit User
|
||||
e.expectJSON(http.StatusOK, &fromHit, "GET", "/api/v1/users/me", alice.token, nil) // второй — попадание в кэш
|
||||
if fromHit != fromMiss || fromHit.ID != alice.user.ID {
|
||||
t.Fatalf("данные из кэша расходятся с БД: %+v vs %+v", fromMiss, fromHit)
|
||||
}
|
||||
}
|
||||
|
||||
// Logout инвалидирует кэш: повторная проверка того же токена видит отзыв,
|
||||
// а не устаревшую "валидную" запись.
|
||||
func TestSessionCacheInvalidatedOnLogout(t *testing.T) {
|
||||
e := newTestEnvWithCache(t)
|
||||
alice := e.mustActor("alice")
|
||||
var me User
|
||||
e.expectJSON(http.StatusOK, &me, "GET", "/api/v1/users/me", alice.token, nil) // прогреваем кэш
|
||||
|
||||
status, _, _ := e.do("DELETE", "/api/v1/auth/sessions/current", alice.token, nil)
|
||||
if status != http.StatusNoContent {
|
||||
t.Fatalf("logout: статус %d", status)
|
||||
}
|
||||
e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/users/me", alice.token, nil)
|
||||
}
|
||||
|
||||
// Недоступность Redis не делает анонимный запрос доверенным и не роняет
|
||||
// авторизацию — она просто идёт мимо кэша прямо в Postgres.
|
||||
func TestSessionValidationSurvivesRedisOutage(t *testing.T) {
|
||||
e := newTestEnv(t) // без кэша в HTTP-слое — Store.ValidateSession проверяем напрямую
|
||||
alice := e.mustActor("alice")
|
||||
|
||||
downCache := &sessionCache{rdb: redis.NewClient(&redis.Options{
|
||||
Addr: "127.0.0.1:1", // ничего не слушает
|
||||
DialTimeout: 200 * time.Millisecond,
|
||||
})}
|
||||
t.Cleanup(func() { downCache.Close() })
|
||||
|
||||
store := NewStore(sharedDB, downCache, time.Hour)
|
||||
u, ok, err := store.ValidateSession(context.Background(), alice.token)
|
||||
if err != nil {
|
||||
t.Fatalf("ValidateSession вернул ошибку при недоступном Redis (должен был обойти кэш и дойти до Postgres): %v", err)
|
||||
}
|
||||
if !ok || u.ID != alice.user.ID {
|
||||
t.Fatalf("валидная сессия не подтвердилась при недоступном Redis: ok=%v u=%+v", ok, u)
|
||||
}
|
||||
|
||||
// Заведомо неверный токен при недоступном Redis — всё равно 401, не "доверяем".
|
||||
_, ok2, err2 := store.ValidateSession(context.Background(), "совершенно-неверный-токен")
|
||||
if err2 != nil {
|
||||
t.Fatalf("неожиданная ошибка: %v", err2)
|
||||
}
|
||||
if ok2 {
|
||||
t.Fatal("недоступность Redis не должна превращать неверный токен в валидный")
|
||||
}
|
||||
}
|
||||
|
||||
// Недоступность PostgreSQL отражается в /health/ready как 503, а не как
|
||||
// "всё хорошо" — и ValidateSession явно возвращает error, а не "валидно".
|
||||
func TestReadyAndAuthReturnUnavailableWhenPostgresDown(t *testing.T) {
|
||||
badDSN := "postgres://messenger:messenger@127.0.0.1:1/messenger?sslmode=disable&connect_timeout=1"
|
||||
badDB, err := pgxpool.New(context.Background(), badDSN)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer badDB.Close()
|
||||
store := NewStore(badDB, nil, time.Hour)
|
||||
|
||||
if err := store.Ready(context.Background()); err == nil {
|
||||
t.Fatal("Ready() должен вернуть ошибку при недоступном Postgres")
|
||||
}
|
||||
|
||||
_, ok, err := store.ValidateSession(context.Background(), "любой-токен")
|
||||
if err == nil {
|
||||
t.Fatal("ValidateSession должен вернуть ошибку (не false без ошибки) при недоступном Postgres")
|
||||
}
|
||||
if ok {
|
||||
t.Fatal("недоступный Postgres не должен трактоваться как «сессия валидна»")
|
||||
}
|
||||
|
||||
srv := httptest.NewServer((&api{store: store}).routes())
|
||||
defer srv.Close()
|
||||
resp, err := http.Get(srv.URL + "/health/ready")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusServiceUnavailable {
|
||||
t.Fatalf("статус %d, ожидали 503", resp.StatusCode)
|
||||
}
|
||||
}
|
||||
|
||||
// TestEmptyListsAreJSONArraysNotNull — регрессия на баг, который поймал
|
||||
// внешний публичный smoke-тест, но не свои: "items":null вместо
|
||||
// "items":[] при пустой истории/списке. encoding/json маршалит nil-слайс
|
||||
// как null, а не []; Go-декодирование в структуру эту разницу прощает
|
||||
// (null в []T остаётся nil-слайсом без ошибки), поэтому проверка делается
|
||||
// по СЫРЫМ байтам ответа, а не через json.Unmarshal в типизированный dst.
|
||||
func TestEmptyListsAreJSONArraysNotNull(t *testing.T) {
|
||||
e := newTestEnv(t)
|
||||
a := e.mustActor("emptylists")
|
||||
|
||||
// Свежий пользователь без единого чата.
|
||||
_, _, data := e.do("GET", "/api/v1/chats", a.token, nil)
|
||||
if !bytes.Contains(data, []byte(`"items":[]`)) {
|
||||
t.Fatalf(`GET /chats без чатов: ожидали "items":[] в сыром JSON, получили: %s`, data)
|
||||
}
|
||||
|
||||
// Чат без единого сообщения.
|
||||
c := e.mustChat(a, "Пустой чат")
|
||||
_, _, data = e.do("GET", "/api/v1/chats/"+c.ID+"/messages", a.token, nil)
|
||||
if !bytes.Contains(data, []byte(`"items":[]`)) {
|
||||
t.Fatalf(`GET /messages без сообщений: ожидали "items":[] в сыром JSON, получили: %s`, data)
|
||||
}
|
||||
}
|
||||
+103
@@ -0,0 +1,103 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
|
||||
"golang.org/x/crypto/argon2"
|
||||
)
|
||||
|
||||
// --- пароли: Argon2id -------------------------------------------------------
|
||||
//
|
||||
// Выбран Argon2id, а не bcrypt: bcrypt молча обрезает пароль до 72 байт,
|
||||
// а у нас пароль — 12..128 Unicode code points без ограничения по алфавиту
|
||||
// (кириллица/эмодзи — 2-4 байта на символ), так что 128 code points легко
|
||||
// превышают 72 байта и bcrypt тихо обрежет "хвост" пароля без ошибки.
|
||||
// Argon2id не имеет такого ограничения и к тому же обязателен для lab7 —
|
||||
// так что это не временное решение, а сразу целевая схема.
|
||||
|
||||
const (
|
||||
argonTime = 3
|
||||
argonMemory = 64 * 1024 // 64 MiB
|
||||
argonThreads = 2
|
||||
argonKeyLen = 32
|
||||
argonSaltLen = 16
|
||||
)
|
||||
|
||||
var errPasswordHashFormat = errors.New("неизвестный формат хэша пароля")
|
||||
|
||||
// validPassword: 12..128 Unicode code points, не только пробелы.
|
||||
// Валидность UTF-8 самого запроса уже проверена в decodeJSON до этого места.
|
||||
func validPassword(s string) bool {
|
||||
n := utf8.RuneCountInString(s)
|
||||
return n >= 12 && n <= 128 && strings.TrimSpace(s) != ""
|
||||
}
|
||||
|
||||
// hashPassword возвращает самоописывающуюся строку: parameters+salt+hash,
|
||||
// поэтому параметры можно менять в будущем без миграции данных (старые
|
||||
// хэши остаются проверяемыми со своими же параметрами).
|
||||
func hashPassword(password string) (string, error) {
|
||||
salt := make([]byte, argonSaltLen)
|
||||
if _, err := rand.Read(salt); err != nil {
|
||||
return "", fmt.Errorf("salt: %w", err)
|
||||
}
|
||||
hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
|
||||
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
|
||||
argon2.Version, argonMemory, argonTime, argonThreads,
|
||||
base64.RawStdEncoding.EncodeToString(salt),
|
||||
base64.RawStdEncoding.EncodeToString(hash)), nil
|
||||
}
|
||||
|
||||
// verifyPassword пересчитывает хэш с параметрами и солью ИЗ сохранённой
|
||||
// строки (а не текущими константами) — старые хэши продолжают проверяться
|
||||
// даже если argonTime/argonMemory поменяются в новой версии бинаря.
|
||||
func verifyPassword(encoded, password string) (bool, error) {
|
||||
parts := strings.Split(encoded, "$")
|
||||
if len(parts) != 6 || parts[1] != "argon2id" {
|
||||
return false, errPasswordHashFormat
|
||||
}
|
||||
var version int
|
||||
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil {
|
||||
return false, errPasswordHashFormat
|
||||
}
|
||||
var memory, time uint32
|
||||
var threads uint8
|
||||
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &time, &threads); err != nil {
|
||||
return false, errPasswordHashFormat
|
||||
}
|
||||
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
|
||||
if err != nil {
|
||||
return false, errPasswordHashFormat
|
||||
}
|
||||
want, err := base64.RawStdEncoding.DecodeString(parts[5])
|
||||
if err != nil {
|
||||
return false, errPasswordHashFormat
|
||||
}
|
||||
got := argon2.IDKey([]byte(password), salt, time, memory, threads, uint32(len(want)))
|
||||
return subtle.ConstantTimeCompare(got, want) == 1, nil
|
||||
}
|
||||
|
||||
// --- сессии: непрозрачный opaque bearer-токен -------------------------------
|
||||
|
||||
// newSessionToken: 32 случайных байта (256 бит энтропии) в base64url без
|
||||
// паддинга — непрозрачное значение, не username/UUID/JWT.
|
||||
func newSessionToken() (string, error) {
|
||||
b := make([]byte, 32)
|
||||
if _, err := rand.Read(b); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return base64.RawURLEncoding.EncodeToString(b), nil
|
||||
}
|
||||
|
||||
// hashToken: в БД/кэше хранится не сам токен, а его SHA-256 — утечка
|
||||
// таблицы сессий/дампа Redis не отдаёт действующие bearer-токены напрямую.
|
||||
func hashToken(token string) []byte {
|
||||
sum := sha256.Sum256([]byte(token))
|
||||
return sum[:]
|
||||
}
|
||||
+130
@@ -0,0 +1,130 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"log/slog"
|
||||
"time"
|
||||
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
// sessionCache — необязательный read-through кэш валидных сессий перед
|
||||
// Postgres. Источник истины всегда Postgres (таблица sessions); Redis
|
||||
// только ускоряет самый горячий путь — проверку Bearer-токена на КАЖДОМ
|
||||
// защищённом запросе. Если sessionCache == nil (CACHE_URL не задан —
|
||||
// уровень 3), store всегда идёт прямо в Postgres: корректность не зависит
|
||||
// от наличия кэша, только скорость.
|
||||
type sessionCache struct {
|
||||
rdb *redis.Client
|
||||
}
|
||||
|
||||
// cachedSession хранит весь User, а не только user_id: при попадании в кэш
|
||||
// это полностью избавляет от похода в Postgres (включая JOIN на users),
|
||||
// а не просто от одной проверки токена — это и есть выигрыш от кэша на
|
||||
// самом горячем пути (Bearer-проверка есть на каждом защищённом запросе).
|
||||
type cachedSession struct {
|
||||
UserID string `json:"user_id"`
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
ExpiresAt time.Time `json:"expires_at"`
|
||||
}
|
||||
|
||||
func newSessionCache(addr string) (*sessionCache, error) {
|
||||
opt, err := redis.ParseURL(addr)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rdb := redis.NewClient(opt)
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
||||
defer cancel()
|
||||
if err := rdb.Ping(ctx).Err(); err != nil {
|
||||
rdb.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &sessionCache{rdb: rdb}, nil
|
||||
}
|
||||
|
||||
func (c *sessionCache) Close() error {
|
||||
if c == nil {
|
||||
return nil
|
||||
}
|
||||
return c.rdb.Close()
|
||||
}
|
||||
|
||||
func cacheKey(tokenHash []byte) string {
|
||||
return "sess:" + string(tokenHash)
|
||||
}
|
||||
|
||||
// get: кэш-промах (ключа нет) и ошибка связи с Redis возвращают одно и то
|
||||
// же — (nil, false) без error — вызывающий код просто идёт в Postgres.
|
||||
// Это и есть "корректно обходит кэш при недоступности": отказ Redis никогда
|
||||
// не трактуется как "сессия валидна" и никогда не роняет запрос — он
|
||||
// просто чуть медленнее идёт в основной источник истины.
|
||||
func (c *sessionCache) get(ctx context.Context, tokenHash []byte) (*cachedSession, bool) {
|
||||
if c == nil {
|
||||
return nil, false
|
||||
}
|
||||
data, err := c.rdb.Get(ctx, cacheKey(tokenHash)).Bytes()
|
||||
if err != nil {
|
||||
if err != redis.Nil {
|
||||
slog.Warn("redis get недоступен, идём в Postgres", "err", err)
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
var s cachedSession
|
||||
if err := json.Unmarshal(data, &s); err != nil {
|
||||
return nil, false
|
||||
}
|
||||
return &s, true
|
||||
}
|
||||
|
||||
// set пишет запись с TTL, равным ОСТАВШЕМУСЯ сроку жизни сессии (не
|
||||
// фиксированному SESSION_TTL_SECONDS) — кэш не может продлить сессию
|
||||
// дольше, чем она реально действует в Postgres.
|
||||
func (c *sessionCache) set(ctx context.Context, tokenHash []byte, u User, expiresAt time.Time) {
|
||||
if c == nil {
|
||||
return
|
||||
}
|
||||
ttl := time.Until(expiresAt)
|
||||
if ttl <= 0 {
|
||||
return
|
||||
}
|
||||
data, err := json.Marshal(cachedSession{
|
||||
UserID: u.ID,
|
||||
Username: u.Username,
|
||||
DisplayName: u.DisplayName,
|
||||
CreatedAt: u.CreatedAt,
|
||||
ExpiresAt: expiresAt,
|
||||
})
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if err := c.rdb.Set(ctx, cacheKey(tokenHash), data, ttl).Err(); err != nil {
|
||||
slog.Warn("redis set недоступен, кэш не обновлён", "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
// del — явная инвалидация при logout. Если Redis в этот момент недоступен,
|
||||
// запись просто не удалится из кэша немедленно, но она не переживёт logout
|
||||
// "навечно": Postgres (источник истины) уже отмечен revoked, а TTL записи
|
||||
// в Redis всё равно не больше исходного срока сессии — на отозванный токен
|
||||
// кэш может ответить "валиден" не дольше, чем он был бы валиден и без
|
||||
// отзыва. Переживший revoke-окно риск — известное и осознанное ограничение,
|
||||
// описанное в REPORT.md.
|
||||
func (c *sessionCache) del(ctx context.Context, tokenHash []byte) {
|
||||
if c == nil {
|
||||
return
|
||||
}
|
||||
if err := c.rdb.Del(ctx, cacheKey(tokenHash)).Err(); err != nil {
|
||||
slog.Warn("redis del недоступен при logout", "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *sessionCache) Ping(ctx context.Context) error {
|
||||
if c == nil {
|
||||
return nil
|
||||
}
|
||||
return c.rdb.Ping(ctx).Err()
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// openPool открывает pgx-пул соединений с ограничениями: без лимита один
|
||||
// зависший клиент/медленный запрос мог бы захватить все соединения Postgres.
|
||||
// pgxpool — "родной" пул для pgx (в отличие от generic database/sql),
|
||||
// с нативной поддержкой PostgreSQL-типов и собственным health-check'ом фона.
|
||||
func openPool(ctx context.Context, dsn string) (*pgxpool.Pool, error) {
|
||||
cfg, err := pgxpool.ParseConfig(dsn)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("парсинг DSN: %w", err)
|
||||
}
|
||||
cfg.MaxConns = 20
|
||||
cfg.MinConns = 1
|
||||
cfg.MaxConnLifetime = 30 * time.Minute
|
||||
cfg.MaxConnIdleTime = 5 * time.Minute
|
||||
|
||||
pool, err := pgxpool.NewWithConfig(ctx, cfg)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("создание пула: %w", err)
|
||||
}
|
||||
|
||||
pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
defer cancel()
|
||||
if err := pool.Ping(pingCtx); err != nil {
|
||||
pool.Close()
|
||||
return nil, fmt.Errorf("ping: %w", err)
|
||||
}
|
||||
return pool, nil
|
||||
}
|
||||
|
||||
// queryTimeout — таймаут на отдельный SQL-запрос: зависший диск/сеть к БД
|
||||
// не должен вешать HTTP-обработчик навечно.
|
||||
const queryTimeout = 3 * time.Second
|
||||
|
||||
func withTimeout(parent context.Context) (context.Context, context.CancelFunc) {
|
||||
return context.WithTimeout(parent, queryTimeout)
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
module messenger
|
||||
|
||||
go 1.22.0
|
||||
|
||||
require (
|
||||
github.com/golang-migrate/migrate/v4 v4.18.1
|
||||
github.com/jackc/pgx/v5 v5.7.1
|
||||
github.com/redis/go-redis/v9 v9.7.0
|
||||
golang.org/x/crypto v0.31.0
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/cespare/xxhash/v2 v2.2.0 // indirect
|
||||
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
|
||||
github.com/hashicorp/errwrap v1.1.0 // indirect
|
||||
github.com/hashicorp/go-multierror v1.1.1 // indirect
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.2 // indirect
|
||||
github.com/lib/pq v1.12.3 // indirect; indirect (используется внутри golang-migrate/database/postgres, не нашим кодом)
|
||||
go.uber.org/atomic v1.7.0 // indirect
|
||||
golang.org/x/sync v0.10.0 // indirect
|
||||
golang.org/x/sys v0.28.0 // indirect
|
||||
golang.org/x/text v0.21.0 // indirect
|
||||
)
|
||||
+93
@@ -0,0 +1,93 @@
|
||||
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
|
||||
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
|
||||
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
|
||||
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
|
||||
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/dhui/dktest v0.4.3 h1:wquqUxAFdcUgabAVLvSCOKOlag5cIZuaOjYIBOWdsR0=
|
||||
github.com/dhui/dktest v0.4.3/go.mod h1:zNK8IwktWzQRm6I/l2Wjp7MakiyaFWv4G1hjmodmMTs=
|
||||
github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
|
||||
github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
|
||||
github.com/docker/docker v27.2.0+incompatible h1:Rk9nIVdfH3+Vz4cyI/uhbINhEZ/oLmc+CBXmH6fbNk4=
|
||||
github.com/docker/docker v27.2.0+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
|
||||
github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
|
||||
github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
|
||||
github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
|
||||
github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
|
||||
github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
|
||||
github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
|
||||
github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
|
||||
github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
|
||||
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
|
||||
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
|
||||
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
|
||||
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
|
||||
github.com/golang-migrate/migrate/v4 v4.18.1 h1:JML/k+t4tpHCpQTCAD62Nu43NUFzHY4CV3uAuvHGC+Y=
|
||||
github.com/golang-migrate/migrate/v4 v4.18.1/go.mod h1:HAX6m3sQgcdO81tdjn5exv20+3Kb13cmGli1hrD6hks=
|
||||
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
|
||||
github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
|
||||
github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
|
||||
github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
|
||||
github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
|
||||
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-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||
github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs=
|
||||
github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA=
|
||||
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
|
||||
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ=
|
||||
github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA=
|
||||
github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
|
||||
github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
|
||||
github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
|
||||
github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
|
||||
github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
|
||||
github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
|
||||
github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
|
||||
github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
|
||||
github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
|
||||
github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
|
||||
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
|
||||
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
|
||||
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.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E=
|
||||
github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw=
|
||||
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.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
|
||||
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
|
||||
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 h1:TT4fX+nBOA/+LUkobKGW1ydGcn+G3vRw9+g5HwCphpk=
|
||||
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8=
|
||||
go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw=
|
||||
go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8=
|
||||
go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc=
|
||||
go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8=
|
||||
go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4=
|
||||
go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ=
|
||||
go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
|
||||
go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
|
||||
golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
|
||||
golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
|
||||
golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
|
||||
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
|
||||
golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
|
||||
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
|
||||
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
|
||||
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=
|
||||
+349
@@ -0,0 +1,349 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type api struct{ store *Store }
|
||||
|
||||
func (a *api) routes() http.Handler {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("GET /health/live", a.live)
|
||||
mux.HandleFunc("GET /health/ready", a.ready)
|
||||
mux.HandleFunc("POST /api/v1/users", a.registerUser)
|
||||
mux.HandleFunc("GET /api/v1/users/me", a.currentUser)
|
||||
mux.HandleFunc("POST /api/v1/auth/sessions", a.createSession)
|
||||
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", a.revokeSession)
|
||||
mux.HandleFunc("POST /api/v1/chats", a.createChat)
|
||||
mux.HandleFunc("GET /api/v1/chats", a.listChats)
|
||||
mux.HandleFunc("GET /api/v1/chats/{chat_id}", a.getChat)
|
||||
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", a.createMessage)
|
||||
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", a.listMessages)
|
||||
// Всё остальное — JSON-ошибка в общем формате.
|
||||
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
||||
writeError(w, http.StatusNotFound, "not_found", "Ресурс не найден")
|
||||
})
|
||||
return withMiddleware(mux)
|
||||
}
|
||||
|
||||
// bearerToken достаёт токен из "Authorization: Bearer <token>".
|
||||
// Пустой/неверный формат/другая схема (например Basic на бизнес-endpoint) — "", false.
|
||||
func bearerToken(r *http.Request) (string, bool) {
|
||||
h := r.Header.Get("Authorization")
|
||||
const prefix = "Bearer "
|
||||
if len(h) <= len(prefix) || !strings.EqualFold(h[:len(prefix)], prefix) {
|
||||
return "", false
|
||||
}
|
||||
token := strings.TrimSpace(h[len(prefix):])
|
||||
if token == "" {
|
||||
return "", false
|
||||
}
|
||||
return token, true
|
||||
}
|
||||
|
||||
// auth — lab2+: защищённые endpoint принимают только Authorization: Bearer
|
||||
// <token> действующей сессии. X-User-Id с lab2 игнорируется полностью: сам
|
||||
// по себе он больше не даёт доступа ни к чему.
|
||||
func (a *api) auth(w http.ResponseWriter, r *http.Request) (User, bool) {
|
||||
token, ok := bearerToken(r)
|
||||
if !ok {
|
||||
unauthorized(w, "Bearer", "Требуется действительный Bearer-токен")
|
||||
return User{}, false
|
||||
}
|
||||
u, valid, err := a.store.ValidateSession(r.Context(), token)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusServiceUnavailable, "unavailable", "Хранилище сессий недоступно")
|
||||
return User{}, false
|
||||
}
|
||||
if !valid {
|
||||
unauthorized(w, "Bearer", "Сессия недействительна, истекла или отозвана")
|
||||
return User{}, false
|
||||
}
|
||||
return u, true
|
||||
}
|
||||
|
||||
// chatID: неверный UUID в пути — 400 (проверяется после аутентификации).
|
||||
func chatID(w http.ResponseWriter, r *http.Request) (string, bool) {
|
||||
id := r.PathValue("chat_id")
|
||||
if !uuidRe.MatchString(id) {
|
||||
badRequest(w, "Некорректный chat_id")
|
||||
return "", false
|
||||
}
|
||||
return strings.ToLower(id), true
|
||||
}
|
||||
|
||||
// pageParams разбирает limit и cursor. scope привязывает курсор к ресурсу.
|
||||
func pageParams(w http.ResponseWriter, r *http.Request, scope string) (limit int, after *pos, ok bool) {
|
||||
q := r.URL.Query()
|
||||
limit = 50
|
||||
if q.Has("limit") {
|
||||
n, err := strconv.Atoi(q.Get("limit"))
|
||||
if err != nil || n < 1 || n > 100 {
|
||||
badRequest(w, "limit должен быть целым числом от 1 до 100")
|
||||
return 0, nil, false
|
||||
}
|
||||
limit = n
|
||||
}
|
||||
if q.Has("cursor") {
|
||||
p, valid := decodeCursor(scope, q.Get("cursor"))
|
||||
if !valid {
|
||||
badRequest(w, "Некорректный cursor")
|
||||
return 0, nil, false
|
||||
}
|
||||
after = p
|
||||
}
|
||||
return limit, after, true
|
||||
}
|
||||
|
||||
func (a *api) live(w http.ResponseWriter, r *http.Request) {
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
// ready: единственная критичная зависимость обязательного синхронного
|
||||
// пути — PostgreSQL. Redis недоступен -> деградация скорости, не отказ.
|
||||
func (a *api) ready(w http.ResponseWriter, r *http.Request) {
|
||||
if err := a.store.Ready(r.Context()); err != nil {
|
||||
writeError(w, http.StatusServiceUnavailable, "unavailable", "PostgreSQL недоступен")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (a *api) registerUser(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
if !decodeJSON(w, r, &req) {
|
||||
return
|
||||
}
|
||||
if !usernameRe.MatchString(req.Username) || !validText(req.DisplayName, 100) || !validPassword(req.Password) {
|
||||
badRequest(w, "Некорректные username, display_name или password")
|
||||
return
|
||||
}
|
||||
hash, err := hashPassword(req.Password)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
u, err := a.store.CreateUser(r.Context(), req.Username, req.DisplayName, hash)
|
||||
if errors.Is(err, errConflict) {
|
||||
writeError(w, http.StatusConflict, "conflict", "Username уже занят")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, u)
|
||||
}
|
||||
|
||||
func (a *api) currentUser(w http.ResponseWriter, r *http.Request) {
|
||||
if u, ok := a.auth(w, r); ok {
|
||||
writeJSON(w, http.StatusOK, u)
|
||||
}
|
||||
}
|
||||
|
||||
// createSession — вход: Authorization: Basic username:password, без JSON body.
|
||||
func (a *api) createSession(w http.ResponseWriter, r *http.Request) {
|
||||
username, password, ok := r.BasicAuth()
|
||||
if !ok {
|
||||
unauthorized(w, "Basic", "Требуется Authorization: Basic username:password")
|
||||
return
|
||||
}
|
||||
u, err := a.store.AuthenticateUser(r.Context(), username, password)
|
||||
if errors.Is(err, errUnauthorized) {
|
||||
unauthorized(w, "Basic", "Неверный username или password")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
session, err := a.store.CreateSession(r.Context(), u)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, session)
|
||||
}
|
||||
|
||||
// revokeSession — logout: отзывает текущий Bearer-токен, 204 без тела.
|
||||
func (a *api) revokeSession(w http.ResponseWriter, r *http.Request) {
|
||||
_, ok := a.auth(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
token, _ := bearerToken(r) // уже проверен в auth()
|
||||
if err := a.store.RevokeSession(r.Context(), token); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
|
||||
func (a *api) createChat(w http.ResponseWriter, r *http.Request) {
|
||||
me, ok := a.auth(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var req struct {
|
||||
Title string `json:"title"`
|
||||
MemberIDs []string `json:"member_ids"`
|
||||
}
|
||||
if !decodeJSON(w, r, &req) {
|
||||
return
|
||||
}
|
||||
if !validText(req.Title, 100) || len(req.MemberIDs) < 1 || len(req.MemberIDs) > 100 {
|
||||
badRequest(w, "Некорректные title или member_ids")
|
||||
return
|
||||
}
|
||||
seen := make(map[string]bool, len(req.MemberIDs))
|
||||
members := make([]string, 0, len(req.MemberIDs))
|
||||
for _, raw := range req.MemberIDs {
|
||||
if !uuidRe.MatchString(raw) {
|
||||
badRequest(w, "Некорректный UUID в member_ids")
|
||||
return
|
||||
}
|
||||
id := strings.ToLower(raw)
|
||||
if seen[id] {
|
||||
badRequest(w, "Дубликаты в member_ids")
|
||||
return
|
||||
}
|
||||
seen[id] = true
|
||||
members = append(members, id)
|
||||
}
|
||||
if !seen[me.ID] {
|
||||
badRequest(w, "member_ids должен включать вызывающего")
|
||||
return
|
||||
}
|
||||
c, err := a.store.CreateChat(r.Context(), req.Title, members)
|
||||
if errors.Is(err, errInvalid) {
|
||||
badRequest(w, "Неизвестный участник в member_ids")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, c)
|
||||
}
|
||||
|
||||
func (a *api) listChats(w http.ResponseWriter, r *http.Request) {
|
||||
me, ok := a.auth(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
limit, after, ok := pageParams(w, r, "c:"+me.ID)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
items, more, err := a.store.ListChats(r.Context(), me.ID, after, limit)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
var next *string
|
||||
if more {
|
||||
last := items[len(items)-1]
|
||||
s := encodeCursor("c:"+me.ID, last.CreatedAt, last.ID)
|
||||
next = &s
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]any{"items": items, "next_cursor": next})
|
||||
}
|
||||
|
||||
func (a *api) getChat(w http.ResponseWriter, r *http.Request) {
|
||||
me, ok := a.auth(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
id, ok := chatID(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
c, err := a.store.GetChat(r.Context(), me.ID, id)
|
||||
if errors.Is(err, errNotFound) {
|
||||
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, c)
|
||||
}
|
||||
|
||||
func (a *api) createMessage(w http.ResponseWriter, r *http.Request) {
|
||||
me, ok := a.auth(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
id, ok := chatID(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
// Порядок из контракта: аутентификация -> доступ к ресурсу -> валидация тела.
|
||||
if _, err := a.store.GetChat(r.Context(), me.ID, id); err != nil {
|
||||
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
|
||||
return
|
||||
}
|
||||
var req struct {
|
||||
Text string `json:"text"` // sender_id не принимается: DisallowUnknownFields даст 400
|
||||
}
|
||||
if !decodeJSON(w, r, &req) {
|
||||
return
|
||||
}
|
||||
if !validText(req.Text, 4000) {
|
||||
badRequest(w, "text должен содержать от 1 до 4000 символов и не состоять из пробелов")
|
||||
return
|
||||
}
|
||||
m, err := a.store.AddMessage(r.Context(), me.ID, id, req.Text)
|
||||
if errors.Is(err, errNotFound) {
|
||||
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, m)
|
||||
}
|
||||
|
||||
func (a *api) listMessages(w http.ResponseWriter, r *http.Request) {
|
||||
me, ok := a.auth(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
id, ok := chatID(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if _, err := a.store.GetChat(r.Context(), me.ID, id); err != nil {
|
||||
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
|
||||
return
|
||||
}
|
||||
limit, after, ok := pageParams(w, r, "m:"+id)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
items, more, err := a.store.ListMessages(r.Context(), me.ID, id, after, limit)
|
||||
if errors.Is(err, errNotFound) {
|
||||
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
var next *string
|
||||
if more {
|
||||
last := items[len(items)-1]
|
||||
s := encodeCursor("m:"+id, last.CreatedAt, last.ID)
|
||||
next = &s
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]any{"items": items, "next_cursor": next})
|
||||
}
|
||||
+220
@@ -0,0 +1,220 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/rand"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"mime"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"runtime/debug"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
var (
|
||||
usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
|
||||
uuidRe = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
|
||||
)
|
||||
|
||||
const maxBodyBytes = 1 << 20 // 1 MiB — с запасом для любого JSON lab1
|
||||
|
||||
func newUUID() string {
|
||||
var b [16]byte
|
||||
if _, err := rand.Read(b[:]); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
b[6] = (b[6] & 0x0f) | 0x40 // version 4
|
||||
b[8] = (b[8] & 0x3f) | 0x80 // variant
|
||||
return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
|
||||
}
|
||||
|
||||
// validText: длина в Unicode code points (не байтах) и не только пробелы.
|
||||
func validText(s string, maxRunes int) bool {
|
||||
n := utf8.RuneCountInString(s)
|
||||
return n >= 1 && n <= maxRunes && strings.TrimSpace(s) != ""
|
||||
}
|
||||
|
||||
// --- ответы ----------------------------------------------------------------
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||||
var buf bytes.Buffer
|
||||
enc := json.NewEncoder(&buf)
|
||||
enc.SetEscapeHTML(false)
|
||||
if err := enc.Encode(v); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
w.Write(buf.Bytes())
|
||||
}
|
||||
|
||||
type errBody struct {
|
||||
Error struct {
|
||||
Code string `json:"code"`
|
||||
Message string `json:"message"`
|
||||
RequestID string `json:"request_id"`
|
||||
} `json:"error"`
|
||||
}
|
||||
|
||||
// writeError берёт request_id из заголовка, который выставил middleware,
|
||||
// поэтому тело и заголовок гарантированно совпадают.
|
||||
func writeError(w http.ResponseWriter, status int, code, message string) {
|
||||
var b errBody
|
||||
b.Error.Code = code
|
||||
b.Error.Message = message
|
||||
b.Error.RequestID = w.Header().Get("X-Request-Id")
|
||||
writeJSON(w, status, b)
|
||||
}
|
||||
|
||||
func badRequest(w http.ResponseWriter, msg string) {
|
||||
writeError(w, http.StatusBadRequest, "invalid_request", msg)
|
||||
}
|
||||
|
||||
// unauthorized: WWW-Authenticate обязан соответствовать схеме, ожидаемой
|
||||
// именно на этом endpoint — Basic на /auth/sessions, Bearer на всех
|
||||
// остальных защищённых endpoint (так требует contracts/README.md и это
|
||||
// же проверяет client.py).
|
||||
func unauthorized(w http.ResponseWriter, scheme, msg string) {
|
||||
switch scheme {
|
||||
case "Basic":
|
||||
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
|
||||
case "Bearer":
|
||||
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
|
||||
}
|
||||
writeError(w, http.StatusUnauthorized, "unauthorized", msg)
|
||||
}
|
||||
|
||||
// decodeJSON: 415 для чужого Content-Type, 413 для огромного тела,
|
||||
// 400 для битого JSON / неверных типов / лишних полей / мусора после объекта /
|
||||
// ключей, отличающихся от поля только регистром / невалидного UTF-8 в строках.
|
||||
func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
|
||||
mt, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
|
||||
if err != nil || mt != "application/json" {
|
||||
writeError(w, http.StatusUnsupportedMediaType, "unsupported_media_type", "Ожидается application/json")
|
||||
return false
|
||||
}
|
||||
r.Body = http.MaxBytesReader(w, r.Body, maxBodyBytes)
|
||||
body, err := io.ReadAll(r.Body)
|
||||
if err != nil {
|
||||
var tooBig *http.MaxBytesError
|
||||
if errors.As(err, &tooBig) {
|
||||
writeError(w, http.StatusRequestEntityTooLarge, "payload_too_large", "Тело запроса слишком большое")
|
||||
} else {
|
||||
badRequest(w, "Некорректный JSON")
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// encoding/json не проверяет валидность UTF-8 при декодировании: битый
|
||||
// байт внутри строки тихо заменяется на U+FFFD (валидный код-пойнт) ещё
|
||||
// на этапе unquote, до того как значение попадёт в Go-строку. Поэтому
|
||||
// проверять decoded-строку уже поздно — надежда только на сырые байты
|
||||
// тела до разбора JSON.
|
||||
if !utf8.Valid(body) {
|
||||
badRequest(w, "Тело запроса содержит невалидный UTF-8")
|
||||
return false
|
||||
}
|
||||
|
||||
dec := json.NewDecoder(bytes.NewReader(body))
|
||||
dec.DisallowUnknownFields()
|
||||
if err := dec.Decode(dst); err != nil {
|
||||
var tooBig *http.MaxBytesError
|
||||
if errors.As(err, &tooBig) {
|
||||
writeError(w, http.StatusRequestEntityTooLarge, "payload_too_large", "Тело запроса слишком большое")
|
||||
} else {
|
||||
badRequest(w, "Некорректный JSON")
|
||||
}
|
||||
return false
|
||||
}
|
||||
if _, err := dec.Token(); err != io.EOF {
|
||||
badRequest(w, "Некорректный JSON")
|
||||
return false
|
||||
}
|
||||
|
||||
// encoding/json сопоставляет JSON-ключ с полем struct без учёта регистра
|
||||
// при точном совпадении имени нет приоритета у DisallowUnknownFields —
|
||||
// он проверяет только "это вообще известное поле", а не "написано так же".
|
||||
// Поэтому {"TEXT": "..."} при наличии json:"text" проходит как известное
|
||||
// поле и тихо перезаписывает значение. Отдельно сверяем точное написание.
|
||||
if !checkExactFieldCase(w, body, dst) {
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// checkExactFieldCase отклоняет тело, где JSON-ключ совпадает с именем поля
|
||||
// struct (по его json-тегу) без учёта регистра, но не совпадает побуквенно —
|
||||
// иначе такой ключ проходит DisallowUnknownFields как "известный" и тихо
|
||||
// перезаписывает значение правильно написанного поля.
|
||||
func checkExactFieldCase(w http.ResponseWriter, body []byte, dst any) bool {
|
||||
var raw map[string]json.RawMessage
|
||||
if err := json.Unmarshal(body, &raw); err != nil {
|
||||
// Не JSON-объект на верхнем уровне — обычный decode уже либо
|
||||
// отработал на примитиве, либо провалился раньше.
|
||||
return true
|
||||
}
|
||||
t := reflect.TypeOf(dst)
|
||||
for t.Kind() == reflect.Ptr {
|
||||
t = t.Elem()
|
||||
}
|
||||
if t.Kind() != reflect.Struct {
|
||||
return true
|
||||
}
|
||||
// lower(json-тег) -> точное написание тега
|
||||
known := make(map[string]string, t.NumField())
|
||||
for i := 0; i < t.NumField(); i++ {
|
||||
name := strings.Split(t.Field(i).Tag.Get("json"), ",")[0]
|
||||
if name == "" || name == "-" {
|
||||
continue
|
||||
}
|
||||
known[strings.ToLower(name)] = name
|
||||
}
|
||||
for key := range raw {
|
||||
if exact, ok := known[strings.ToLower(key)]; ok && key != exact {
|
||||
badRequest(w, "Поле \""+key+"\" отличается от \""+exact+"\" только регистром")
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// --- middleware ------------------------------------------------------------
|
||||
|
||||
type statusRecorder struct {
|
||||
http.ResponseWriter
|
||||
status int
|
||||
}
|
||||
|
||||
func (s *statusRecorder) WriteHeader(code int) {
|
||||
s.status = code
|
||||
s.ResponseWriter.WriteHeader(code)
|
||||
}
|
||||
|
||||
// withMiddleware: request id -> access log -> recover -> handler.
|
||||
// В логах только метод, путь (без query), статус и время: тексты сообщений не попадают.
|
||||
func withMiddleware(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
rid := newUUID()
|
||||
w.Header().Set("X-Request-Id", rid)
|
||||
rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
|
||||
start := time.Now()
|
||||
defer func() {
|
||||
if p := recover(); p != nil {
|
||||
slog.Error("panic", "request_id", rid, "panic", fmt.Sprint(p), "stack", string(debug.Stack()))
|
||||
writeError(rec, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
|
||||
}
|
||||
slog.Info("request", "request_id", rid, "method", r.Method, "path", r.URL.Path,
|
||||
"status", rec.status, "duration_ms", time.Since(start).Milliseconds())
|
||||
}()
|
||||
next.ServeHTTP(rec, r)
|
||||
})
|
||||
}
|
||||
+151
@@ -0,0 +1,151 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"flag"
|
||||
"log/slog"
|
||||
"net"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
)
|
||||
|
||||
func env(key, def string) string {
|
||||
if v := os.Getenv(key); v != "" {
|
||||
return v
|
||||
}
|
||||
return def
|
||||
}
|
||||
|
||||
// secret читает значение либо из файла, на который указывает <KEY>_FILE
|
||||
// (Docker secrets — так рекомендует .env.example), либо из обычной
|
||||
// переменной <KEY>, либо берёт def. Секреты никогда не передаются в
|
||||
// командной строке/аргументах процесса — только файл или переменная
|
||||
// окружения самого контейнера.
|
||||
func secret(key, def string) string {
|
||||
if path := os.Getenv(key + "_FILE"); path != "" {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
slog.Error("не удалось прочитать secret-файл", "env", key+"_FILE", "path", path, "err", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
return strings.TrimSpace(string(data))
|
||||
}
|
||||
return env(key, def)
|
||||
}
|
||||
|
||||
// probe нужен для Docker HEALTHCHECK в минимальном образе, где нет curl/wget:
|
||||
//
|
||||
// HEALTHCHECK CMD ["/app/messenger", "-healthcheck"]
|
||||
func probe(port string) int {
|
||||
c := http.Client{Timeout: 2 * time.Second}
|
||||
resp, err := c.Get("http://" + net.JoinHostPort("127.0.0.1", port) + "/health/ready")
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func main() {
|
||||
healthcheck := flag.Bool("healthcheck", false, "проверить /health/ready и выйти с кодом 0/1")
|
||||
flag.Parse()
|
||||
|
||||
host := env("APP_HOST", "0.0.0.0")
|
||||
port := env("APP_PORT", "8080")
|
||||
if *healthcheck {
|
||||
os.Exit(probe(port))
|
||||
}
|
||||
|
||||
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
|
||||
|
||||
// Дефолт — только для локального запуска без Docker secrets; в compose
|
||||
// значение приходит из DATABASE_URL_FILE (см. .env.example/compose.yaml).
|
||||
dsn := secret("DATABASE_URL", "postgres://messenger:messenger@localhost:5432/messenger?sslmode=disable")
|
||||
|
||||
// Миграции применяются ДО открытия рабочего pgxpool.Pool: golang-migrate
|
||||
// работает через свой короткоживущий database/sql-коннект (см. migrate.go),
|
||||
// отдельный от пула приложения.
|
||||
if err := runMigrations(dsn); err != nil {
|
||||
slog.Error("миграции не применились", "err", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
ctx0, cancel0 := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
db, err := openPool(ctx0, dsn)
|
||||
cancel0()
|
||||
if err != nil {
|
||||
slog.Error("не удалось подключиться к PostgreSQL", "err", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
// CACHE_URL не задан => работаем без Redis (level 3: только Postgres,
|
||||
// корректность не зависит от кэша). CACHE_URL задан => level 4: кэш
|
||||
// сессий обязателен к работе на старте — если он должен быть, но не
|
||||
// поднимается, лучше не стартовать вслепую.
|
||||
var cache *sessionCache
|
||||
if cacheURL := secret("CACHE_URL", ""); cacheURL != "" {
|
||||
cache, err = newSessionCache(cacheURL)
|
||||
if err != nil {
|
||||
slog.Error("не удалось подключиться к Redis/Valkey", "err", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
defer cache.Close()
|
||||
slog.Info("кэш сессий включён", "cache_url_set", true)
|
||||
} else {
|
||||
slog.Info("кэш сессий выключен: CACHE_URL не задан, работаем только с PostgreSQL")
|
||||
}
|
||||
|
||||
ttlSeconds, err := strconv.Atoi(env("SESSION_TTL_SECONDS", "3600"))
|
||||
if err != nil || ttlSeconds <= 0 {
|
||||
slog.Error("SESSION_TTL_SECONDS должен быть положительным целым", "value", env("SESSION_TTL_SECONDS", "3600"))
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
store := NewStore(db, cache, time.Duration(ttlSeconds)*time.Second)
|
||||
|
||||
srv := &http.Server{
|
||||
Addr: net.JoinHostPort(host, port),
|
||||
Handler: (&api{store: store}).routes(),
|
||||
ReadHeaderTimeout: 5 * time.Second,
|
||||
ReadTimeout: 15 * time.Second,
|
||||
WriteTimeout: 15 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
}
|
||||
|
||||
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
||||
defer stop()
|
||||
|
||||
errCh := make(chan error, 1)
|
||||
go func() {
|
||||
slog.Info("listening", "addr", srv.Addr, "env", env("APP_ENV", "lab"))
|
||||
errCh <- srv.ListenAndServe()
|
||||
}()
|
||||
|
||||
select {
|
||||
case err := <-errCh:
|
||||
slog.Error("server failed", "err", err)
|
||||
os.Exit(1)
|
||||
case <-ctx.Done():
|
||||
}
|
||||
|
||||
// Shutdown сразу закрывает listener (новые соединения не принимаются)
|
||||
// и ждёт завершения текущих запросов. Бюджет 8 с < 10 с из рубрики.
|
||||
// db/cache закрываются через defer выше, после возврата из main.
|
||||
slog.Info("shutting down")
|
||||
sctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
|
||||
defer cancel()
|
||||
if err := srv.Shutdown(sctx); err != nil {
|
||||
slog.Warn("graceful shutdown timed out, forcing close", "err", err)
|
||||
srv.Close()
|
||||
}
|
||||
slog.Info("stopped")
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"embed"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/golang-migrate/migrate/v4"
|
||||
"github.com/golang-migrate/migrate/v4/database/postgres"
|
||||
"github.com/golang-migrate/migrate/v4/source/iofs"
|
||||
_ "github.com/jackc/pgx/v5/stdlib" // регистрирует pgx как database/sql-драйвер "pgx" — нужен только здесь
|
||||
)
|
||||
|
||||
// Миграции запекаются в бинарь: один артефакт, нечему потеряться между
|
||||
// образом и файловой системой хоста.
|
||||
//
|
||||
//go:embed migrations/*.sql
|
||||
var migrationsFS embed.FS
|
||||
|
||||
// runMigrations применяет все непримененные миграции через golang-migrate
|
||||
// (стандартная, проверенная библиотека для этого — а не самодельный раннер).
|
||||
//
|
||||
// golang-migrate работает поверх интерфейса database/sql, которого у pgxpool
|
||||
// нет (это "родной" pgx-пул, а не database/sql.DB). Поэтому здесь открывается
|
||||
// ОТДЕЛЬНОЕ, короткоживущее *sql.DB через pgx-овский stdlib-адаптер — только
|
||||
// на время применения миграций при старте; рабочий пул приложения (pgxpool.Pool,
|
||||
// см. db.go) для обычных запросов — он отдельный и остаётся на всё время жизни
|
||||
// процесса.
|
||||
func runMigrations(dsn string) error {
|
||||
db, err := sql.Open("pgx", dsn)
|
||||
if err != nil {
|
||||
return fmt.Errorf("открыть соединение для миграций: %w", err)
|
||||
}
|
||||
defer db.Close()
|
||||
|
||||
srcDriver, err := iofs.New(migrationsFS, "migrations")
|
||||
if err != nil {
|
||||
return fmt.Errorf("источник миграций: %w", err)
|
||||
}
|
||||
|
||||
dbDriver, err := postgres.WithInstance(db, &postgres.Config{})
|
||||
if err != nil {
|
||||
return fmt.Errorf("драйвер БД для migrate: %w", err)
|
||||
}
|
||||
|
||||
m, err := migrate.NewWithInstance("iofs", srcDriver, "postgres", dbDriver)
|
||||
if err != nil {
|
||||
return fmt.Errorf("инициализация migrate: %w", err)
|
||||
}
|
||||
defer m.Close()
|
||||
|
||||
if err := m.Up(); err != nil && !errors.Is(err, migrate.ErrNoChange) {
|
||||
return fmt.Errorf("применение миграций: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
DROP TABLE IF EXISTS sessions;
|
||||
DROP TABLE IF EXISTS messages;
|
||||
DROP TABLE IF EXISTS chat_members;
|
||||
DROP TABLE IF EXISTS chats;
|
||||
DROP TABLE IF EXISTS users;
|
||||
@@ -0,0 +1,71 @@
|
||||
-- Лаб2: пользователи, чаты, участники, сообщения, сессии.
|
||||
-- Транзакционные границы и обоснование индексов — см. db/README.md.
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_name_not_blank CHECK (btrim(display_name) <> '')
|
||||
);
|
||||
|
||||
-- Уникальность username на уровне БД — это и есть защита от гонки двух
|
||||
-- параллельных регистраций одного имени: кто вставился первым, тот и
|
||||
-- выиграл, второй получает unique_violation (23505) -> 409 conflict.
|
||||
CREATE UNIQUE INDEX users_username_key ON users (username);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT chats_title_not_blank CHECK (btrim(title) <> '')
|
||||
);
|
||||
|
||||
-- Участники чата: отдельная таблица связи, а не массив в chats —
|
||||
-- позволяет FK-проверку существования пользователя силами БД и
|
||||
-- normалized lookup "мои чаты" через индекс по user_id.
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
-- "Чаты пользователя" читаются по user_id, а не по chat_id (который ведущий
|
||||
-- столбец первичного ключа) — нужен отдельный индекс в обратном порядке.
|
||||
CREATE INDEX chat_members_user_id_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT messages_text_not_blank CHECK (btrim(text) <> '')
|
||||
);
|
||||
|
||||
-- Ключевой индекс лабы: keyset-пагинация истории чата делает
|
||||
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
-- ORDER BY created_at, id LIMIT $4
|
||||
-- Композитный индекс (chat_id, created_at, id) превращает это в range scan
|
||||
-- по одному чату вместо full scan всей таблицы сообщений на каждую
|
||||
-- страницу. EXPLAIN (ANALYZE, BUFFERS) на ≥10k строк — в evidence/.
|
||||
CREATE INDEX messages_chat_created_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
-- Храним не сам токен, а SHA-256 от него: утечка таблицы сессий не
|
||||
-- выдаёт действующие bearer-токены напрямую (та же логика, что и для
|
||||
-- паролей — только тут это "ещё один слой", а не KDF: токен сам по
|
||||
-- себе уже 256 бит случайности).
|
||||
token_hash bytea PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
expires_at timestamptz NOT NULL,
|
||||
revoked_at timestamptz
|
||||
);
|
||||
|
||||
-- Периодическая очистка истёкших/отозванных сессий (не обязательна для
|
||||
-- корректности — expires_at/revoked_at проверяются в каждом запросе —
|
||||
-- но нужна, чтобы таблица не росла бесконечно).
|
||||
CREATE INDEX sessions_expires_at_idx ON sessions (expires_at);
|
||||
+511
@@ -0,0 +1,511 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"errors"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// Фиксированная ширина (6 знаков) => строки курсора сравниваются
|
||||
// лексикографически так же, как время. Формат: RFC 3339 UTC с "Z".
|
||||
const tsLayout = "2006-01-02T15:04:05.000000Z"
|
||||
|
||||
var (
|
||||
errConflict = errors.New("conflict")
|
||||
errInvalid = errors.New("invalid")
|
||||
errNotFound = errors.New("not found")
|
||||
errUnauthorized = errors.New("unauthorized")
|
||||
)
|
||||
|
||||
type User struct {
|
||||
ID string `json:"id"`
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
type Chat struct {
|
||||
ID string `json:"id"`
|
||||
Title string `json:"title"`
|
||||
MemberIDs []string `json:"member_ids"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
type Message struct {
|
||||
ID string `json:"id"`
|
||||
ChatID string `json:"chat_id"`
|
||||
SenderID string `json:"sender_id"`
|
||||
Text string `json:"text"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
type Session struct {
|
||||
Token string `json:"token"`
|
||||
TokenType string `json:"token_type"`
|
||||
ExpiresAt string `json:"expires_at"`
|
||||
User User `json:"user"`
|
||||
}
|
||||
|
||||
func formatTS(t time.Time) string { return t.UTC().Format(tsLayout) }
|
||||
|
||||
// Store — тонкая обёртка над *pgxpool.Pool (+ опциональный Redis-кэш сессий).
|
||||
// Пул соединений и его лимиты настраиваются в openPool; здесь только запросы.
|
||||
type Store struct {
|
||||
db *pgxpool.Pool
|
||||
cache *sessionCache // nil => кэш не настроен, работаем только с Postgres
|
||||
sessionTTL time.Duration
|
||||
}
|
||||
|
||||
func NewStore(db *pgxpool.Pool, cache *sessionCache, sessionTTL time.Duration) *Store {
|
||||
return &Store{db: db, cache: cache, sessionTTL: sessionTTL}
|
||||
}
|
||||
|
||||
// isUniqueViolation: SQLSTATE 23505 — PostgreSQL error code для unique_violation.
|
||||
func isUniqueViolation(err error) bool {
|
||||
var pgErr *pgconn.PgError
|
||||
return errors.As(err, &pgErr) && pgErr.Code == "23505"
|
||||
}
|
||||
|
||||
// isForeignKeyViolation: SQLSTATE 23503 — ссылка на несуществующую строку
|
||||
// (например, неизвестный user_id в chat_members).
|
||||
func isForeignKeyViolation(err error) bool {
|
||||
var pgErr *pgconn.PgError
|
||||
return errors.As(err, &pgErr) && pgErr.Code == "23503"
|
||||
}
|
||||
|
||||
func (s *Store) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
u := User{ID: newUUID(), Username: username, DisplayName: displayName}
|
||||
var createdAt time.Time
|
||||
err := s.db.QueryRow(ctx,
|
||||
`INSERT INTO users (id, username, display_name, password_hash)
|
||||
VALUES ($1, $2, $3, $4) RETURNING created_at`,
|
||||
u.ID, username, displayName, passwordHash).Scan(&createdAt)
|
||||
if err != nil {
|
||||
if isUniqueViolation(err) {
|
||||
return User{}, errConflict
|
||||
}
|
||||
return User{}, err
|
||||
}
|
||||
u.CreatedAt = formatTS(createdAt)
|
||||
return u, nil
|
||||
}
|
||||
|
||||
func (s *Store) GetUser(ctx context.Context, id string) (User, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
var u User
|
||||
var createdAt time.Time
|
||||
err := s.db.QueryRow(ctx,
|
||||
`SELECT id, username, display_name, created_at FROM users WHERE id = $1`,
|
||||
id).Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return User{}, errNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return User{}, err
|
||||
}
|
||||
u.CreatedAt = formatTS(createdAt)
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// AuthenticateUser проверяет Basic username:password. Несуществующий
|
||||
// username и неверный пароль дают одну и ту же ошибку — чтобы ответ не
|
||||
// раскрывал, какой username существует.
|
||||
func (s *Store) AuthenticateUser(ctx context.Context, username, password string) (User, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
var u User
|
||||
var createdAt time.Time
|
||||
var hash string
|
||||
err := s.db.QueryRow(ctx,
|
||||
`SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1`,
|
||||
username).Scan(&u.ID, &u.Username, &u.DisplayName, &hash, &createdAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return User{}, errUnauthorized
|
||||
}
|
||||
if err != nil {
|
||||
return User{}, err
|
||||
}
|
||||
ok, err := verifyPassword(hash, password)
|
||||
if err != nil || !ok {
|
||||
return User{}, errUnauthorized
|
||||
}
|
||||
u.CreatedAt = formatTS(createdAt)
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// CreateChat — атомарная составная операция: вставка чата и всех строк
|
||||
// членства в одной транзакции. Неизвестный участник нарушает FK на
|
||||
// chat_members.user_id -> откат целиком, ни чат, ни частичный список
|
||||
// участников не остаются в БД.
|
||||
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []string) (Chat, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
tx, err := s.db.Begin(ctx)
|
||||
if err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
defer tx.Rollback(ctx) //nolint:errcheck — не влияет после успешного Commit
|
||||
|
||||
c := Chat{ID: newUUID(), Title: title, MemberIDs: memberIDs}
|
||||
var createdAt time.Time
|
||||
if err := tx.QueryRow(ctx,
|
||||
`INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at`,
|
||||
c.ID, title).Scan(&createdAt); err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
|
||||
if _, err := tx.Exec(ctx,
|
||||
`INSERT INTO chat_members (chat_id, user_id)
|
||||
SELECT $1, unnest($2::uuid[])`,
|
||||
c.ID, memberIDs); err != nil {
|
||||
if isForeignKeyViolation(err) {
|
||||
return Chat{}, errInvalid
|
||||
}
|
||||
return Chat{}, err
|
||||
}
|
||||
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
c.CreatedAt = formatTS(createdAt)
|
||||
return c, nil
|
||||
}
|
||||
|
||||
// GetChat возвращает чат, только если userID — его участник; чужой и
|
||||
// несуществующий чат неразличимы (оба errNotFound — так и задано в контракте).
|
||||
func (s *Store) GetChat(ctx context.Context, userID, chatID string) (Chat, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
var c Chat
|
||||
var createdAt time.Time
|
||||
err := s.db.QueryRow(ctx,
|
||||
`SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $2
|
||||
WHERE c.id = $1`,
|
||||
chatID, userID).Scan(&c.ID, &c.Title, &createdAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return Chat{}, errNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
members, err := s.chatMembers(ctx, c.ID)
|
||||
if err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
c.MemberIDs = members
|
||||
c.CreatedAt = formatTS(createdAt)
|
||||
return c, nil
|
||||
}
|
||||
|
||||
func (s *Store) chatMembers(ctx context.Context, chatID string) ([]string, error) {
|
||||
rows, err := s.db.Query(ctx,
|
||||
`SELECT user_id FROM chat_members WHERE chat_id = $1`, chatID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
// make(..., 0), не var out []string: nil-слайс маршалится в JSON как
|
||||
// null, а не [] — контракт (и smoke-тест) ожидает массив даже пустой.
|
||||
out := make([]string, 0)
|
||||
for rows.Next() {
|
||||
var id string
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, id)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
func (s *Store) AddMessage(ctx context.Context, userID, chatID, text string) (Message, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
var isMember bool
|
||||
if err := s.db.QueryRow(ctx,
|
||||
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
|
||||
chatID, userID).Scan(&isMember); err != nil {
|
||||
return Message{}, err
|
||||
}
|
||||
if !isMember {
|
||||
return Message{}, errNotFound
|
||||
}
|
||||
m := Message{ID: newUUID(), ChatID: chatID, SenderID: userID, Text: text}
|
||||
var createdAt time.Time
|
||||
err := s.db.QueryRow(ctx,
|
||||
`INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, clock_timestamp()) RETURNING created_at`,
|
||||
m.ID, chatID, userID, text).Scan(&createdAt)
|
||||
if err != nil {
|
||||
return Message{}, err
|
||||
}
|
||||
m.CreatedAt = formatTS(createdAt)
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// ListMessages — keyset-пагинация: fetch limit+1 строк, чтобы одним запросом
|
||||
// узнать и страницу, и есть ли следующая, без отдельного COUNT(*).
|
||||
func (s *Store) ListMessages(ctx context.Context, userID, chatID string, after *pos, limit int) ([]Message, bool, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
var isMember bool
|
||||
if err := s.db.QueryRow(ctx,
|
||||
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
|
||||
chatID, userID).Scan(&isMember); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
if !isMember {
|
||||
return nil, false, errNotFound
|
||||
}
|
||||
|
||||
var rows pgx.Rows
|
||||
var err error
|
||||
if after == nil {
|
||||
rows, err = s.db.Query(ctx,
|
||||
`SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2`,
|
||||
chatID, limit+1)
|
||||
} else {
|
||||
rows, err = s.db.Query(ctx,
|
||||
`SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2::timestamptz, $3::uuid)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4`,
|
||||
chatID, after.ts, after.id, limit+1)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
// make(..., 0), не var out []Message: nil-слайс маршалится в JSON как
|
||||
// null, а не [] — "items" в ответе должен быть массивом даже пустым.
|
||||
out := make([]Message, 0)
|
||||
for rows.Next() {
|
||||
var m Message
|
||||
var createdAt time.Time
|
||||
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &createdAt); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
m.CreatedAt = formatTS(createdAt)
|
||||
out = append(out, m)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
more := len(out) > limit
|
||||
if more {
|
||||
out = out[:limit]
|
||||
}
|
||||
return out, more, nil
|
||||
}
|
||||
|
||||
func (s *Store) ListChats(ctx context.Context, userID string, after *pos, limit int) ([]Chat, bool, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
var rows pgx.Rows
|
||||
var err error
|
||||
if after == nil {
|
||||
rows, err = s.db.Query(ctx,
|
||||
`SELECT c.id, c.title, c.created_at
|
||||
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
|
||||
WHERE cm.user_id = $1
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $2`,
|
||||
userID, limit+1)
|
||||
} else {
|
||||
rows, err = s.db.Query(ctx,
|
||||
`SELECT c.id, c.title, c.created_at
|
||||
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
|
||||
WHERE cm.user_id = $1 AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid)
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $4`,
|
||||
userID, after.ts, after.id, limit+1)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
// make(..., 0), не var out []Chat: та же причина, что в ListMessages.
|
||||
out := make([]Chat, 0)
|
||||
for rows.Next() {
|
||||
var c Chat
|
||||
var createdAt time.Time
|
||||
if err := rows.Scan(&c.ID, &c.Title, &createdAt); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
c.CreatedAt = formatTS(createdAt)
|
||||
out = append(out, c)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
more := len(out) > limit
|
||||
if more {
|
||||
out = out[:limit]
|
||||
}
|
||||
// member_ids для каждого чата страницы — одним batched-запросом, не N+1.
|
||||
if len(out) > 0 {
|
||||
ids := make([]string, len(out))
|
||||
for i, c := range out {
|
||||
ids[i] = c.ID
|
||||
}
|
||||
memberRows, err := s.db.Query(ctx,
|
||||
`SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[])`,
|
||||
ids)
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
members := make(map[string][]string, len(out))
|
||||
for memberRows.Next() {
|
||||
var chatID, memberID string
|
||||
if err := memberRows.Scan(&chatID, &memberID); err != nil {
|
||||
memberRows.Close()
|
||||
return nil, false, err
|
||||
}
|
||||
members[chatID] = append(members[chatID], memberID)
|
||||
}
|
||||
memberRows.Close()
|
||||
if err := memberRows.Err(); err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
for i := range out {
|
||||
out[i].MemberIDs = members[out[i].ID]
|
||||
}
|
||||
}
|
||||
return out, more, nil
|
||||
}
|
||||
|
||||
// --- сессии ------------------------------------------------------------
|
||||
|
||||
// CreateSession выдаёт новый opaque bearer-токен поверх уже
|
||||
// аутентифицированного пользователя (см. AuthenticateUser) и кладёт его в
|
||||
// Postgres (источник истины) и, если настроен, в кэш.
|
||||
func (s *Store) CreateSession(ctx context.Context, u User) (Session, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
token, err := newSessionToken()
|
||||
if err != nil {
|
||||
return Session{}, err
|
||||
}
|
||||
hash := hashToken(token)
|
||||
expiresAt := time.Now().UTC().Add(s.sessionTTL)
|
||||
if _, err := s.db.Exec(ctx,
|
||||
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, $3)`,
|
||||
hash, u.ID, expiresAt); err != nil {
|
||||
return Session{}, err
|
||||
}
|
||||
s.cache.set(ctx, hash, u, expiresAt)
|
||||
return Session{
|
||||
Token: token,
|
||||
TokenType: "Bearer",
|
||||
ExpiresAt: formatTS(expiresAt),
|
||||
User: u,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// ValidateSession — горячий путь: сначала кэш (если настроен), затем
|
||||
// Postgres. Любой сбой кэша (промах ИЛИ ошибка связи) просто идёт в
|
||||
// Postgres — отказ Redis никогда не трактуется как "токен валиден" и
|
||||
// никогда не трактуется как "запрос анонимный, но пропустим".
|
||||
func (s *Store) ValidateSession(ctx context.Context, token string) (User, bool, error) {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
hash := hashToken(token)
|
||||
|
||||
if cached, hit := s.cache.get(ctx, hash); hit {
|
||||
if time.Now().UTC().Before(cached.ExpiresAt) {
|
||||
return User{
|
||||
ID: cached.UserID,
|
||||
Username: cached.Username,
|
||||
DisplayName: cached.DisplayName,
|
||||
CreatedAt: cached.CreatedAt,
|
||||
}, true, nil
|
||||
}
|
||||
// Кэш отстал от собственного TTL (часы/гонка) — не доверяем, идём в Postgres.
|
||||
}
|
||||
|
||||
var u User
|
||||
var createdAt, expiresAt time.Time
|
||||
err := s.db.QueryRow(ctx,
|
||||
`SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
|
||||
FROM sessions s JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()`,
|
||||
hash).Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt, &expiresAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return User{}, false, nil
|
||||
}
|
||||
if err != nil {
|
||||
return User{}, false, err
|
||||
}
|
||||
u.CreatedAt = formatTS(createdAt)
|
||||
s.cache.set(ctx, hash, u, expiresAt)
|
||||
return u, true, nil
|
||||
}
|
||||
|
||||
func (s *Store) RevokeSession(ctx context.Context, token string) error {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
hash := hashToken(token)
|
||||
if _, err := s.db.Exec(ctx,
|
||||
`UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL`,
|
||||
hash); err != nil {
|
||||
return err
|
||||
}
|
||||
s.cache.del(ctx, hash)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Ready — критична только доступность Postgres: это единственная
|
||||
// зависимость обязательного синхронного пути (без БД ни один endpoint не
|
||||
// может правильно ответить). Redis — не критичен: его отсутствие замедляет
|
||||
// проверку Bearer-токена, но ValidateSession сам уходит в Postgres.
|
||||
func (s *Store) Ready(ctx context.Context) error {
|
||||
ctx, cancel := withTimeout(ctx)
|
||||
defer cancel()
|
||||
return s.db.Ping(ctx)
|
||||
}
|
||||
|
||||
// --- keyset cursor -----------------------------------------------------
|
||||
|
||||
// pos — позиция последнего отданного элемента. Курсор привязан к scope
|
||||
// ("m:<chat_id>" или "c:<user_id>"), поэтому курсор чужого чата даёт 400.
|
||||
type pos struct{ ts, id string }
|
||||
|
||||
func encodeCursor(scope, ts, id string) string {
|
||||
return base64.RawURLEncoding.EncodeToString([]byte(scope + "|" + ts + "|" + id))
|
||||
}
|
||||
|
||||
func decodeCursor(scope, raw string) (*pos, bool) {
|
||||
b, err := base64.RawURLEncoding.DecodeString(raw)
|
||||
if err != nil {
|
||||
return nil, false
|
||||
}
|
||||
parts := strings.Split(string(b), "|")
|
||||
if len(parts) != 3 || parts[0] != scope || parts[1] == "" || parts[2] == "" {
|
||||
return nil, false
|
||||
}
|
||||
// Непустые строки — не значит валидные. ts должен быть настоящей меткой
|
||||
// времени нашего формата, id — настоящим UUID: без этого структурно
|
||||
// похожий, но мусорный курсор тихо дал бы пустую страницу вместо 400.
|
||||
if _, err := time.Parse(tsLayout, parts[1]); err != nil {
|
||||
return nil, false
|
||||
}
|
||||
if !uuidRe.MatchString(parts[2]) {
|
||||
return nil, false
|
||||
}
|
||||
return &pos{ts: parts[1], id: parts[2]}, true
|
||||
}
|
||||
Reference in New Issue
Block a user