diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..59986d78 --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/REPORT.md b/REPORT.md index e42f2b05..0a06b471 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,109 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Стругов Максим БПИ2303 +- Целевая оценка: **4** +- Использованные источники, библиотеки и помощь ИИ: контракт курса (`contracts/openapi.json`, `contracts/README.md`, `contracts/infrastructure.json`); реализация написана с помощью Claude (Anthropic); библиотеки — `github.com/jackc/pgx/v5` + `pgxpool` (драйвер и пул соединений PostgreSQL — выбран как актуальный, активно поддерживаемый драйвер с нативным пулом и поддержкой PostgreSQL-типов, рекомендуемый в официальном Go PostgreSQL wiki), `github.com/golang-migrate/migrate/v4` (миграции — стандартный, широко используемый инструмент, а не самодельное решение), `github.com/redis/go-redis/v9`, `golang.org/x/crypto/argon2` (KDF паролей). Миграции хранятся как `.sql`-файлы, встроенные в бинарь через `//go:embed` (источник `iofs` для `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/` в `.gitignore` целиком, поэтому после `git clone` этой папки/файлов нет — их нужно создать локально перед первым запуском (ни один секрет не коммитится): + ```bash + mkdir -p secrets + 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 через `pgxpool.Pool` (нативный pgx-пул, не `database/sql`), пул с лимитами и таймаутами на каждый запрос; `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 при недоступности кэша. Миграции — `golang-migrate`, применяются при старте через короткоживущее `database/sql`-соединение (адаптер `pgx/v5/stdlib`), отдельное от рабочего `pgxpool.Pool` приложения. + +**Соответствие `.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 требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Структура репозитория и контракт | `make check` | `PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.` (проверяет только структуру, не приложение) | `evidence/make_check.txt` | +| Публичный smoke (уровень 3) | `make test` (против `docker compose up -d --build`) | `PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.` | `evidence/make_test.txt` | +| Схема/индексы спроектированы до запросов | — | Все таблицы, constraint'ы, индексы и транзакционные границы описаны и обоснованы заранее | `db/README.md` | +| PostgreSQL вместо in-memory, параметризованные запросы, пул соединений с таймаутами | — | Все запросы через `$N`-параметры (`pgx/v5`); `pgxpool.Config.MaxConns`/`MinConns`/`MaxConnLifetime`/`MaxConnIdleTime`; `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 24.439s` (последний прогон после всех исправлений) | Покрыто тестами входа/выхода/истечения/неверного пароля | `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` | +| Отзыв токена при отказе Redis | `go test` | `TestRevokedTokenRejectedWhenRedisDelFails` (ACL `-del`: надгробие), `TestRevokedTokenRejectedWhenRedisDelAndSetFail` (ACL `-del -set`: локальный deny-list), `TestRevokedTokenStaysRevokedAfterAPIRestart` (права Redis возвращены, перезапущен только API → сверка при старте), `TestRevokedTokenStaysRevokedAfterRestartWhileRedisStillDenies` (рестарт при всё ещё запрещённых `DEL`/`SET` → deny-list из PostgreSQL): после logout чтение истории, `GET /users/me` и отправка сообщения → `401` | `src/api_test.go`, `src/cache.go`, `src/store.go` | +| Отказ PostgreSQL при прогретой сессии | `go test` | `TestPostgresDownWithWarmSessionReturns503`: история, отправка, список чатов, `GET /chats/{id}` и вход (Basic) → `503 unavailable`, не `404`/`500`; анонимного доступа нет | `src/api_test.go`, `src/handlers.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 приложения и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.` Данные и сессия сохранились (`sessions`/`messages` — обычные таблицы в volume `pgdata`, не in-memory). Оговорка самого теста: вывод хука скрыт, поэтому что именно делает `scripts/restart.sh`, видно только из самого скрипта | `evidence/test_persistence.txt`, `scripts/restart.sh` | +| Выбранный трек 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 сессии не продлён рестартом | Подтверждено: `make test-persistence` с хуком `scripts/restart.sh` — `PASS` | Потери данных нет; время восстановления не замерялось | + +Условия всех прогонов: локальный PostgreSQL 16 и Redis 7, без искусственной конкурентной нагрузки на сам сервер (цель — корректность поведения при сбое зависимости, не пропускная способность). `go test -race -count=1 ./...` → `ok messenger 24.439s` (последний прогон после всех исправлений), `go vet ./...` и `gofmt -l .` — чисто. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +**Выдерживается:** race на регистрацию username; атомарность создания чата с rollback; деградация при падении Redis (без ложного "valid") и при падении Postgres (503, не анонимный доступ); персистентность данных на уровне схемы (обычные таблицы в volume, не in-memory структуры). + +**Отзыв токена не зависит от успеха операций с Redis.** Порядок logout: (1) `revoked_at` в PostgreSQL (источник истины); (2) инвалидация кэша — `DEL`; если `DEL` не прошёл (отказ связи, ACL `-del`) — запись заменяется «надгробием» (`revoked=true`) обычным `SET`, и чтение, увидев надгробие, не доверяет кэшу, а идёт в PostgreSQL; (3) если не прошёл и `SET` — токен попадает в локальный in-memory deny-list `Store` и отклоняется с `401` до конца срока сессии; (4) deny-list и надгробия не переживают рестарт процесса, а запись в Redis, которую не удалось инвалидировать, переживает — поэтому при старте API, до приёма запросов, `Store.ReconcileRevoked` читает из PostgreSQL все отозванные и ещё не истёкшие сессии (`revoked_at IS NOT NULL AND expires_at > now()`) и повторяет для них инвалидацию кэша (`DEL` → надгробие → deny-list уже из БД). Ошибка чтения из PostgreSQL на этом шаге фатальна для старта. Дополнительно TTL записи кэша ограничен `min(остаток сессии, 1 минута)`, поэтому даже при отказе всех трёх шагов (другая реплика с тем же Redis) окно устаревания не превышает минуту. Прежняя формулировка «осознанного ограничения» (отозванный токен может отвечать из кэша) снята: она была ошибкой, проверяющий воспроизвёл её сценарием `ACL SETUSER default -del`. + +**Остаточный риск, который остаётся:** гонка «запрос прочитал валидную сессию из PostgreSQL → параллельный logout отозвал и инвалидировал кэш → запрос записал в кэш устаревшую запись». Её окно ограничено `cacheMaxTTL` (1 минута), надгробие её не закрывает. + +**Не реализовано (вне скоупа лабы 2, ожидается в следующих лабах по контракту):** `X-Instance-Id`, `Idempotency-Key`, балансировка нескольких реплик (с лабы 3); вложения (с лабы 4); фоновая обработка (с лабы 5); HTTPS (обязателен с лабы 7). + +**Инфраструктурное ограничение, зафиксированное сознательно:** `compose.yaml` не публикует порт PostgreSQL (`5432`) на хост — база не должна быть доступна снаружи сети compose. Это означает, что собственный набор `go test` (в отличие от публичного `make test`, которому хватает HTTP) нужно гонять либо против отдельного локального Postgres, либо временно открыв порт на время разработки — описано в разделе "Запуск из чистого clone". + +**Как проверено:** код писался в среде без доступа к Docker Hub, поэтому логика (миграции, Postgres-store, Argon2id, Bearer-сессии, Redis-кэш) проверялась `go test -race` против настоящих локальных PostgreSQL 16 и Redis 7, не моков. Docker-стек затем поднят на машине автора: `docker compose up -d --build`, после чего пройдены `make check`, `make test` и `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (вывод в `evidence/`). + +**Замечание по миграциям:** на БД, где ранее уже была таблица `schema_migrations` другого формата (без колонки `dirty`), `golang-migrate` падает при старте. Решается сбросом volume (`docker compose down -v`); на чистом clone проблемы нет. \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..5d6fbd82 --- /dev/null +++ b/compose.yaml @@ -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 читает именно + # файл, на который указывает _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: diff --git a/db/README.md b/db/README.md new file mode 100644 index 00000000..32af79ee --- /dev/null +++ b/db/README.md @@ -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). diff --git a/evidence/explain_pagination.txt b/evidence/explain_pagination.txt new file mode 100644 index 00000000..85fd73a0 --- /dev/null +++ b/evidence/explain_pagination.txt @@ -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) дешёвой +независимо от того, насколько длинная история чата и на какой +странице стоит курсор. + diff --git a/evidence/make_check.txt b/evidence/make_check.txt new file mode 100644 index 00000000..9a553306 --- /dev/null +++ b/evidence/make_check.txt @@ -0,0 +1,2 @@ +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. diff --git a/evidence/make_test.txt b/evidence/make_test.txt new file mode 100644 index 00000000..404a2c60 --- /dev/null +++ b/evidence/make_test.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/manual_revocation_restart.txt b/evidence/manual_revocation_restart.txt new file mode 100644 index 00000000..f630d082 --- /dev/null +++ b/evidence/manual_revocation_restart.txt @@ -0,0 +1,5 @@ +Сценарий: логин -> прогрев кэша -> ACL SETUSER default -del -set -> logout -> ACL SETUSER default +del +set -> docker compose restart api -> тот же токен + +GET /users/me до logout: 200 +DELETE /auth/sessions/current: 204 +GET /users/me после restart api: 401 diff --git a/evidence/test_persistence.txt b/evidence/test_persistence.txt new file mode 100644 index 00000000..793b001d --- /dev/null +++ b/evidence/test_persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..43dd6384 --- /dev/null +++ b/scripts/restart.sh @@ -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 diff --git a/src/api_test.go b/src/api_test.go new file mode 100644 index 00000000..ea669527 --- /dev/null +++ b/src/api_test.go @@ -0,0 +1,1051 @@ +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) + } +} + +// --- замечания проверяющего: отзыв токена и отказ PostgreSQL ---------------- + +// denyRedisCommands запрещает команды default-пользователю Redis (как в +// сценарии проверяющего: ACL SETUSER default -del) и возвращает их при Cleanup. +func denyRedisCommands(t *testing.T, e *testEnv, cmds ...string) (restore func()) { + t.Helper() + addr := os.Getenv("TEST_CACHE_URL") + if addr == "" { + addr = "redis://localhost:6379/0" + } + opt, err := redis.ParseURL(addr) + if err != nil { + t.Fatal(err) + } + admin := redis.NewClient(opt) + args := []any{"ACL", "SETUSER", "default"} + back := []any{"ACL", "SETUSER", "default"} + for _, c := range cmds { + args = append(args, "-"+c) + back = append(back, "+"+c) + } + if err := admin.Do(context.Background(), args...).Err(); err != nil { + t.Fatalf("ACL SETUSER: %v", err) + } + restore = func() { admin.Do(context.Background(), back...) } + t.Cleanup(func() { + restore() + admin.Close() + }) + return restore +} + +func assertRevoked(t *testing.T, e *testEnv, a actor, chatID string) { + t.Helper() + e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/users/me", a.token, nil) + e.expectErr(http.StatusUnauthorized, "unauthorized", "GET", "/api/v1/chats/"+chatID+"/messages", a.token, nil) + e.expectErr(http.StatusUnauthorized, "unauthorized", "POST", "/api/v1/chats/"+chatID+"/messages", a.token, map[string]string{"text": "после logout"}) +} + +// Logout при запрещённом DEL: Postgres отозван, а кэш не должен отдавать +// токен как валидный (чтение и запись -> 401). +func TestRevokedTokenRejectedWhenRedisDelFails(t *testing.T) { + e := newTestEnvWithCache(t) + alice := e.mustActor("alice") + c := e.mustChat(alice, "Чат") + e.expectJSON(http.StatusOK, &User{}, "GET", "/api/v1/users/me", alice.token, nil) // прогрев кэша + + denyRedisCommands(t, e, "del") + status, _, _ := e.do("DELETE", "/api/v1/auth/sessions/current", alice.token, nil) + if status != http.StatusNoContent { + t.Fatalf("logout: статус %d", status) + } + assertRevoked(t, e, alice, c.ID) +} + +// Худший случай: Redis не даёт ни DEL, ни SET (надгробие) — токен всё равно +// закрыт локальным deny-list. +func TestRevokedTokenRejectedWhenRedisDelAndSetFail(t *testing.T) { + e := newTestEnvWithCache(t) + alice := e.mustActor("alice") + c := e.mustChat(alice, "Чат") + e.expectJSON(http.StatusOK, &User{}, "GET", "/api/v1/users/me", alice.token, nil) + + denyRedisCommands(t, e, "del", "set") + status, _, _ := e.do("DELETE", "/api/v1/auth/sessions/current", alice.token, nil) + if status != http.StatusNoContent { + t.Fatalf("logout: статус %d", status) + } + assertRevoked(t, e, alice, c.ID) +} + +// Отказ PostgreSQL при прогретой (из кэша валидной) сессии: любой защищённый +// endpoint отдаёт 503 unavailable, а не 404/500; анонимного доступа нет. +func TestPostgresDownWithWarmSessionReturns503(t *testing.T) { + e := newTestEnvWithCache(t) + alice := e.mustActor("alice") + c := e.mustChat(alice, "Чат") + e.expectJSON(http.StatusOK, &User{}, "GET", "/api/v1/users/me", alice.token, nil) // кэш прогрет + + // Тот же кэш, но Postgres недоступен. + badDB, err := pgxpool.New(context.Background(), + "postgres://messenger:messenger@127.0.0.1:1/messenger?sslmode=disable&connect_timeout=1") + if err != nil { + t.Fatal(err) + } + t.Cleanup(badDB.Close) + addr := os.Getenv("TEST_CACHE_URL") + if addr == "" { + addr = "redis://localhost:6379/0" + } + cache, err := newSessionCache(addr) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cache.Close() }) + srv := httptest.NewServer((&api{store: NewStore(badDB, cache, time.Hour)}).routes()) + t.Cleanup(srv.Close) + down := &testEnv{t: t, url: srv.URL} + + down.expectErr(http.StatusServiceUnavailable, "unavailable", "GET", "/api/v1/chats/"+c.ID+"/messages", alice.token, nil) + down.expectErr(http.StatusServiceUnavailable, "unavailable", "POST", "/api/v1/chats/"+c.ID+"/messages", alice.token, map[string]string{"text": "x"}) + down.expectErr(http.StatusServiceUnavailable, "unavailable", "GET", "/api/v1/chats", alice.token, nil) + down.expectErr(http.StatusServiceUnavailable, "unavailable", "GET", "/api/v1/chats/"+c.ID, alice.token, nil) + + // Вход (Basic) при недоступной БД — тоже 503, не 500. + status, _, _, err := down.send("POST", "/api/v1/auth/sessions", "", nil, + basicAuthHeader(alice.user.Username, "любой-пароль-12+")) + if err != nil { + t.Fatal(err) + } + if status != http.StatusServiceUnavailable { + t.Fatalf("вход при недоступной БД: статус %d, ожидали 503", status) + } +} + +// restartedAPI имитирует `docker compose restart api` при работающих +// PostgreSQL и Redis: новый Store (пустой deny-list в памяти) над теми же +// БД и Redis, со сверкой отозванных сессий при старте, как в main(). +func restartedAPI(t *testing.T) *testEnv { + t.Helper() + addr := os.Getenv("TEST_CACHE_URL") + if addr == "" { + addr = "redis://localhost:6379/0" + } + cache, err := newSessionCache(addr) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { cache.Close() }) + store := NewStore(sharedDB, cache, time.Hour) + if err := store.ReconcileRevoked(context.Background()); err != nil { + t.Fatalf("ReconcileRevoked: %v", err) + } + srv := httptest.NewServer((&api{store: store}).routes()) + t.Cleanup(srv.Close) + return &testEnv{t: t, url: srv.URL} +} + +// Сценарий проверяющего: DEL и SET запрещены, logout -> 204, права +// возвращены, перезапуск ТОЛЬКО API (PostgreSQL и Redis живы). Старая запись +// осталась в Redis, но отозванный токен обязан получать 401. +func TestRevokedTokenStaysRevokedAfterAPIRestart(t *testing.T) { + e := newTestEnvWithCache(t) + alice := e.mustActor("alice") + c := e.mustChat(alice, "Чат") + e.expectJSON(http.StatusOK, &User{}, "GET", "/api/v1/users/me", alice.token, nil) // прогрев кэша + + restore := denyRedisCommands(t, e, "del", "set") + status, _, _ := e.do("DELETE", "/api/v1/auth/sessions/current", alice.token, nil) + if status != http.StatusNoContent { + t.Fatalf("logout: статус %d", status) + } + assertRevoked(t, e, alice, c.ID) // до рестарта — 401 (локальный deny-list) + restore() + + after := restartedAPI(t) + assertRevoked(t, after, alice, c.ID) +} + +// Тот же рестарт, но права Redis так и не вернули: при старте нельзя ни +// удалить запись, ни поставить надгробие — токен закрывается deny-list'ом, +// собранным из PostgreSQL. +func TestRevokedTokenStaysRevokedAfterRestartWhileRedisStillDenies(t *testing.T) { + e := newTestEnvWithCache(t) + alice := e.mustActor("alice") + c := e.mustChat(alice, "Чат") + e.expectJSON(http.StatusOK, &User{}, "GET", "/api/v1/users/me", alice.token, nil) + + denyRedisCommands(t, e, "del", "set") + status, _, _ := e.do("DELETE", "/api/v1/auth/sessions/current", alice.token, nil) + if status != http.StatusNoContent { + t.Fatalf("logout: статус %d", status) + } + + after := restartedAPI(t) // права Redis всё ещё запрещены + assertRevoked(t, after, alice, c.ID) +} \ No newline at end of file diff --git a/src/auth.go b/src/auth.go new file mode 100644 index 00000000..cc8c0fcb --- /dev/null +++ b/src/auth.go @@ -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[:] +} diff --git a/src/cache.go b/src/cache.go new file mode 100644 index 00000000..6a8e07ac --- /dev/null +++ b/src/cache.go @@ -0,0 +1,154 @@ +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"` + // Revoked — надгробие, которое ставит logout, если DEL не удался: + // запись нельзя использовать как подтверждение сессии. + Revoked bool `json:"revoked,omitempty"` +} + +// cacheMaxTTL ограничивает срок жизни записи независимо от срока сессии: +// даже в худшем случае (отказ и DEL, и SET при logout, другая реплика) кэш +// не может дольше этого окна отдавать уже отозванный токен как валидный. +const cacheMaxTTL = time.Minute + +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 = min(ОСТАВШИЙСЯ срок сессии, cacheMaxTTL) — кэш +// не может продлить сессию дольше, чем она реально действует в 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 + } + if ttl > cacheMaxTTL { + ttl = cacheMaxTTL + } + 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) + } +} + +// invalidate — инвалидация записи при logout (Postgres к этому моменту уже +// отмечен revoked). Возвращает true, только если кэш гарантированно больше +// не отдаст токен как «валидный»: +// 1. DEL ключа; если DEL не прошёл (ошибка связи, ACL запрещает DEL...) — +// 2. запись-надгробие (revoked=true) поверх ключа обычным SET: чтение +// видит надгробие и идёт в Postgres, а не доверяет кэшу. +// +// Если не прошло и это — false: вызывающий код обязан закрыть токен иначе +// (локальный deny-list в Store), а не молча оставить кэш «валидным». +func (c *sessionCache) invalidate(ctx context.Context, tokenHash []byte, ttl time.Duration) bool { + if c == nil { + return true + } + key := cacheKey(tokenHash) + err := c.rdb.Del(ctx, key).Err() + if err == nil { + return true + } + slog.Warn("redis del не прошёл при logout, ставим надгробие", "err", err) + if ttl <= 0 { + ttl = time.Minute + } + data, _ := json.Marshal(cachedSession{Revoked: true}) + if err := c.rdb.Set(ctx, key, data, ttl).Err(); err != nil { + slog.Error("redis: не удалось ни удалить, ни пометить запись отозванной", "err", err) + return false + } + return true +} + +func (c *sessionCache) Ping(ctx context.Context) error { + if c == nil { + return nil + } + return c.rdb.Ping(ctx).Err() +} diff --git a/src/db.go b/src/db.go new file mode 100644 index 00000000..63046ac8 --- /dev/null +++ b/src/db.go @@ -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) +} diff --git a/src/go.mod b/src/go.mod new file mode 100644 index 00000000..1bed2b15 --- /dev/null +++ b/src/go.mod @@ -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 +) diff --git a/src/go.sum b/src/go.sum new file mode 100644 index 00000000..7863c2ea --- /dev/null +++ b/src/go.sum @@ -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= diff --git a/src/handlers.go b/src/handlers.go new file mode 100644 index 00000000..ea74efea --- /dev/null +++ b/src/handlers.go @@ -0,0 +1,405 @@ +package main + +import ( + "context" + "errors" + "io" + "net" + "net/http" + "strconv" + "strings" + + "github.com/jackc/pgx/v5/pgconn" +) + +type api struct{ store *Store } + +// isUnavailable: ошибка означает «зависимость недоступна» (обрыв/отказ +// соединения, таймаут, остановка сервера PostgreSQL), а не логическую +// ошибку запроса или баг. Такие ошибки отдаются как 503, не 404/500. +func isUnavailable(err error) bool { + if err == nil { + return false + } + if errors.Is(err, context.DeadlineExceeded) || + errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) { + return true + } + var netErr net.Error + if errors.As(err, &netErr) { + return true + } + var connErr *pgconn.ConnectError + if errors.As(err, &connErr) { + return true + } + if pgconn.SafeToRetry(err) || pgconn.Timeout(err) { + return true + } + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) { + // 08 — connection exception, 57P — admin shutdown/crash/cannot connect now, + // 53 — нехватка ресурсов сервера. + c := pgErr.Code + return strings.HasPrefix(c, "08") || strings.HasPrefix(c, "57P") || strings.HasPrefix(c, "53") + } + msg := err.Error() + return strings.Contains(msg, "conn closed") || strings.Contains(msg, "closed pool") +} + +// writeStoreError превращает неожиданную ошибку хранилища в ответ: +// недоступность БД -> 503 unavailable, всё прочее -> 500. +func writeStoreError(w http.ResponseWriter, err error) { + if isUnavailable(err) { + writeError(w, http.StatusServiceUnavailable, "unavailable", "Хранилище недоступно") + return + } + writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка") +} + +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 ". +// Пустой/неверный формат/другая схема (например 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 +// действующей сессии. 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 { + writeStoreError(w, err) + 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 { + writeStoreError(w, err) + 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 { + writeStoreError(w, err) + return + } + session, err := a.store.CreateSession(r.Context(), u) + if err != nil { + writeStoreError(w, err) + 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 { + writeStoreError(w, err) + 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 { + writeStoreError(w, err) + 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 { + writeStoreError(w, err) + 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 { + writeStoreError(w, err) + 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 { + if errors.Is(err, errNotFound) { + writeError(w, http.StatusNotFound, "not_found", "Чат не найден") + } else { + writeStoreError(w, err) // отказ БД — 503/500, а не «чата нет» + } + 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 { + writeStoreError(w, err) + 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 { + if errors.Is(err, errNotFound) { + writeError(w, http.StatusNotFound, "not_found", "Чат не найден") + } else { + writeStoreError(w, err) // отказ БД — 503/500, а не «чата нет» + } + 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 { + writeStoreError(w, err) + 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}) +} diff --git a/src/httpx.go b/src/httpx.go new file mode 100644 index 00000000..55febba1 --- /dev/null +++ b/src/httpx.go @@ -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) + }) +} diff --git a/src/main.go b/src/main.go new file mode 100644 index 00000000..92f2793a --- /dev/null +++ b/src/main.go @@ -0,0 +1,161 @@ +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 читает значение либо из файла, на который указывает _FILE +// (Docker secrets — так рекомендует .env.example), либо из обычной +// переменной , либо берёт 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) + + // Отзыв токена должен переживать рестарт API: до приёма запросов + // повторяем инвалидацию кэша для всех отозванных, но не истёкших сессий. + rctx, rcancel := context.WithTimeout(context.Background(), 30*time.Second) + if err := store.ReconcileRevoked(rctx); err != nil { + rcancel() + slog.Error("не удалось сверить отозванные сессии с кэшем", "err", err) + os.Exit(1) + } + rcancel() + + 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") +} \ No newline at end of file diff --git a/src/migrate.go b/src/migrate.go new file mode 100644 index 00000000..943f9fdf --- /dev/null +++ b/src/migrate.go @@ -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 +} diff --git a/src/migrations/0001_init.down.sql b/src/migrations/0001_init.down.sql new file mode 100644 index 00000000..a3ba4f2d --- /dev/null +++ b/src/migrations/0001_init.down.sql @@ -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; diff --git a/src/migrations/0001_init.up.sql b/src/migrations/0001_init.up.sql new file mode 100644 index 00000000..3a14617d --- /dev/null +++ b/src/migrations/0001_init.up.sql @@ -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); diff --git a/src/store.go b/src/store.go new file mode 100644 index 00000000..39847baa --- /dev/null +++ b/src/store.go @@ -0,0 +1,595 @@ +package main + +import ( + "context" + "encoding/base64" + "errors" + "log/slog" + "strings" + "sync" + "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 + revoked sync.Map // string(token_hash) -> time.Time: см. denyLocally +} + +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) + + // Локальный deny-list: токен, который logout не смог инвалидировать в Redis. + if s.locallyRevoked(hash) { + return User{}, false, nil + } + + // Надгробие (Revoked) не подтверждает сессию — решает Postgres. + if cached, hit := s.cache.get(ctx, hash); hit && !cached.Revoked { + 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 + } + // Postgres уже отозвал токен. Если кэш не удалось инвалидировать ни DEL, + // ни надгробием — закрываем токен локально, а не оставляем «валидным». + if !s.cache.invalidate(ctx, hash, s.sessionTTL) { + s.denyLocally(hash, time.Now().Add(s.sessionTTL)) + } + return nil +} + +// denyLocally/locallyRevoked — in-memory deny-list отозванных токенов на +// случай, когда Redis не позволил инвалидировать запись. Записи живут не +// дольше срока сессии и вычищаются при добавлении новых. +func (s *Store) denyLocally(hash []byte, until time.Time) { + now := time.Now() + s.revoked.Range(func(k, v any) bool { + if now.After(v.(time.Time)) { + s.revoked.Delete(k) + } + return true + }) + s.revoked.Store(string(hash), until) +} + +// ReconcileRevoked вызывается при старте процесса, ДО приёма запросов. +// Локальный deny-list и надгробия живут недолго или только в памяти и не +// переживают рестарт API, а запись в Redis, которую logout не смог +// инвалидировать, — переживает. Источник истины об отзыве — Postgres +// (revoked_at), поэтому для каждой отозванной и ещё не истёкшей сессии +// повторяем инвалидацию кэша; если Redis по-прежнему не даёт ни DEL, ни +// SET — токен заносится в локальный deny-list уже из БД. Ошибка чтения из +// Postgres фатальна для старта: без неё нельзя гарантировать, что отозванный +// токен не оживёт из кэша. +func (s *Store) ReconcileRevoked(ctx context.Context) error { + if s.cache == nil { + return nil + } + rows, err := s.db.Query(ctx, + `SELECT token_hash, expires_at FROM sessions + WHERE revoked_at IS NOT NULL AND expires_at > now()`) + if err != nil { + return err + } + type revokedSession struct { + hash []byte + expiresAt time.Time + } + var revoked []revokedSession + for rows.Next() { + var r revokedSession + if err := rows.Scan(&r.hash, &r.expiresAt); err != nil { + rows.Close() + return err + } + revoked = append(revoked, r) + } + rows.Close() // освобождаем соединение до походов в Redis + if err := rows.Err(); err != nil { + return err + } + for _, r := range revoked { + if !s.cache.invalidate(ctx, r.hash, time.Until(r.expiresAt)) { + s.denyLocally(r.hash, r.expiresAt) + } + } + slog.Info("отозванные сессии сверены с кэшем", "count", len(revoked)) + return nil +} + +func (s *Store) locallyRevoked(hash []byte) bool { + v, ok := s.revoked.Load(string(hash)) + if !ok { + return false + } + if time.Now().After(v.(time.Time)) { + s.revoked.Delete(string(hash)) + return false + } + return true +} + +// 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:" или "c:"), поэтому курсор чужого чата даёт 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 +} \ No newline at end of file