From bdccb3ad7ddef4e7bed5607ad1ad46cfd08a5761 Mon Sep 17 00:00:00 2001 From: wanderinho Date: Tue, 10 Nov 2026 15:19:31 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=A03=20-=20=D0=91=D0=9F=D0=982303=20-?= =?UTF-8?q?=20=D0=A1=D1=82=D1=80=D1=83=D0=B3=D0=BE=D0=B2=20-=20=D0=BD?= =?UTF-8?q?=D0=B0=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 21 + REPORT.md | 116 ++- compose.yaml | 70 ++ evidence/load.json | 17 + evidence/make_check.txt | 2 + evidence/make_test.txt | 2 + evidence/make_validate.txt | 2 + evidence/migrations.txt | 5 + evidence/rolling-load.json | 17 + evidence/test_failover.txt | 4 + evidence/test_persistence.txt | 3 + infra/nginx.conf | 26 + scripts/init-secrets.sh | 10 + scripts/restart.sh | 5 + scripts/restore.sh | 8 + scripts/rolling-update.sh | 71 ++ scripts/stop-one.sh | 14 + src/api_test.go | 1127 ++++++++++++++++++++++ src/auth.go | 103 ++ src/cache.go | 154 +++ src/db.go | 45 + src/go.mod | 25 + src/go.sum | 93 ++ src/handlers.go | 430 +++++++++ src/httpx.go | 232 +++++ src/main.go | 157 +++ src/migrate.go | 57 ++ src/migrations/0001_init.down.sql | 5 + src/migrations/0001_init.up.sql | 71 ++ src/migrations/0002_idempotency.down.sql | 1 + src/migrations/0002_idempotency.up.sql | 7 + src/store.go | 636 ++++++++++++ tests/idempotency_concurrent.py | 78 ++ 33 files changed, 3591 insertions(+), 23 deletions(-) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 evidence/load.json create mode 100644 evidence/make_check.txt create mode 100644 evidence/make_test.txt create mode 100644 evidence/make_validate.txt create mode 100644 evidence/migrations.txt create mode 100644 evidence/rolling-load.json create mode 100644 evidence/test_failover.txt create mode 100644 evidence/test_persistence.txt create mode 100644 infra/nginx.conf create mode 100755 scripts/init-secrets.sh create mode 100755 scripts/restart.sh create mode 100755 scripts/restore.sh create mode 100755 scripts/rolling-update.sh create mode 100755 scripts/stop-one.sh create mode 100644 src/api_test.go create mode 100644 src/auth.go create mode 100644 src/cache.go create mode 100644 src/db.go create mode 100644 src/go.mod create mode 100644 src/go.sum create mode 100644 src/handlers.go create mode 100644 src/httpx.go create mode 100644 src/main.go create mode 100644 src/migrate.go create mode 100644 src/migrations/0001_init.down.sql create mode 100644 src/migrations/0001_init.up.sql create mode 100644 src/migrations/0002_idempotency.down.sql create mode 100644 src/migrations/0002_idempotency.up.sql create mode 100644 src/store.go create mode 100644 tests/idempotency_concurrent.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..9c2f2617 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,21 @@ +FROM golang:1.22.5-alpine AS build +WORKDIR /src + +COPY src/go.mod src/go.sum ./ +RUN go mod download + +COPY src/ ./ + +RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger . + + +FROM scratch +USER 10001:10001 + +COPY --from=build /out/messenger /app/messenger + +EXPOSE 8080 +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 c2679005..6a37713d 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,107 @@ -# Отчёт — лабораторная 3 +# Отчёт — лабораторная работа № 3 (целевая оценка: 4) -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +**Автор:** Стругов Максим +**Группа:** БПИ2303 +**Целевая оценка:** 4 -## Запуск из чистого clone +## 1. Воспроизводимый запуск -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требования: Docker Engine и Docker Compose plugin; Go на хосте не требуется; Python 3.9+ для проверочных скриптов. -## Архитектура и решения +```sh +cp .env.example .env +./scripts/init-secrets.sh +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --scale api=2 --wait +make check +make validate +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +./scripts/restore.sh +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +После восстановления реплик проверить `docker compose ps api`: должны работать два экземпляра API со статусом `healthy`. -## Доказательства критериев +Публично опубликован только адрес `127.0.0.1:8080` балансировщика Nginx. API, PostgreSQL и Redis доступны внутри сети Docker Compose, но не публикуют свои порты на хост. Данные PostgreSQL сохраняются в Docker volume. Команда `docker compose down` останавливает стек без удаления данных; `docker compose down -v` **удаляет тома и учебные данные**, поэтому используется только осознанно. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +Секреты создаются локально, не должны попадать в Git. Для `secrets/database_url.txt` и `secrets/cache_url.txt` установлены права `640`, группа `10001` — GID процесса API. После изменения прав контейнер API был перезапущен и успешно достиг состояния `healthy`. + +## 2. Архитектура и технические решения + +**Схема:** клиент → Nginx 1.27.5 → две реплики Go API → общие PostgreSQL 16.4 и Redis 7.4. + +- **Реплики API.** Приложение не хранит критическое состояние в локальной памяти контейнера. Обе реплики работают с общими PostgreSQL и Redis. Заголовок `X-Instance-Id` содержит идентификатор экземпляра и позволяет проверить распределение запросов. +- **Сессии.** PostgreSQL — источник истины для пользователей, чатов, сообщений и сессий. Решение о действительности Bearer-токена принимается по PostgreSQL; положительный ответ Redis-кэша не используется как самостоятельное подтверждение доступа. Это предотвращает доверие устаревшей записи после отзыва токена на другой реплике. +- **Идемпотентность.** Для создания сообщений используется `Idempotency-Key`; в PostgreSQL действует уникальность `(user_id, chat_id, key)`. Запись сообщения и ключа идемпотентности выполняется транзакционно. В рамках лабораторной тело запроса канонизируется как текст и пустой список вложений. +- **Балансировщик.** Nginx использует Docker DNS `127.0.0.11` и динамическое разрешение `api:8080` (`resolve`, `valid=2s`). Настроены `proxy_connect_timeout 1s`, `proxy_read_timeout 12s`, `proxy_send_timeout 12s` и максимум две upstream-попытки при предусмотренных сетевых ошибках. Автоматический повтор уже отправленного POST не гарантируется: повтор небезопасен без учёта идемпотентности. +- **Healthcheck и остановка.** Проверка здоровья контейнера выполняется каждые 5 секунд. Go HTTP-сервер использует graceful shutdown с тайм-аутом 8 секунд; Compose задаёт `stop_grace_period: 10s`. +- **Миграции.** Отдельный одноразовый сервис `migrate` запускает `golang-migrate` до старта API. SQL-миграции встроены в Go-бинарь через `go:embed`; применённые версии учитываются в `schema_migrations`. + +**Особенность настройки Nginx по результатам эксперимента:** в upstream добавлено `server api:8080 resolve max_fails=0;`. Параметр отключает пассивное исключение адреса после неудачных попыток соединения. Это помогло в повторном испытании, но означает, что Nginx может продолжать выбирать недоступный IP до обновления Docker DNS. Активных health probes upstream в данной конфигурации нет. + +## 3. Проверки и доказательства + +| Критерий | Команда / сценарий | Фактический результат | Доказательство | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Структура репозитория | `make check` | `PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.` | Вывод терминала; при сдаче сохранить в `evidence/` | +| OpenAPI 3.1 и JSON Schema | `make validate` | `PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.` | Вывод терминала | +| Публичный API | `make test` | `PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.` | Вывод терминала | +| Персистентность | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.` | Вывод терминала и `scripts/restart.sh` | +| Отказ одной реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 115 успешных записей, 0 неудачных попыток, первая успешная запись после воздействия через 0,474 с; тест завершился `PASS` | Вывод JSON и `scripts/stop-one.sh` | +| Балансировка | 20 последовательных запросов `/health/live` | В ответах наблюдались два разных `X-Instance-Id`, соответствующие двум репликам | Вывод `curl` | +| Конкурентная идемпотентность | `python3 tests/idempotency_concurrent.py` | 20 параллельных запросов с одинаковым ключом, один уникальный ID сообщения, ответы от двух реплик; `PASS` | Вывод теста; файл скрипта | +| Обычная нагрузка до обновления | `python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load.json` | 11 816 успешных запросов, 0 ошибок; 393,589 успешных запросов/с; p50 7,992 мс, p95 27,642 мс, p99 46,719 мс | `evidence/load.json` | +| Замена под нагрузкой | `scripts/rolling-update.sh` одновременно с `tests/load.py` | **35 685 успешных POST, 0 ошибок; обе реплики заменены и стали `healthy`** | `evidence/rolling-load.json`, `evidence/rolling-update.log` | +| Версия миграций | `SELECT version, dirty FROM schema_migrations;` | `version=2`, `dirty=false` | Вывод `psql` | +| Доступ к секретам | `chmod 640`, `ls -l`, перезапуск одной реплики | Группа файлов `10001`, режим `640`; перезапущенная `api-6` стала `healthy`, `api-7` оставалась `healthy` | Вывод `ls`, `docker inspect`, `docker compose ps api` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +### 3.1. Проверка отказа одной реплики -## Эксперименты и отказы +Тест `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` завершился успешно: 115 записей, 0 неудачных попыток, первая успешная запись после воздействия через 0,474 секунды. Дополнительно вручную остановлена одна реплика, а запрос к `/health/live` через Nginx продолжил возвращать HTTP 200 от второй. После запуска остановленной реплики и перехода в `healthy` Nginx снова распределял запросы между двумя `X-Instance-Id`. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Указанное время 0,474 секунды — метрика конкретного теста, а не гарантия максимального времени восстановления при любых условиях. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +### 3.2. Поочерёдная замена реплик под нагрузкой -## Ограничения и следующие шаги +Использован сценарий **эквивалентной поочерёдной замены контейнеров** Docker Compose, а не обновление образа на новую версию приложения. Скрипт запоминает ID двух исходных контейнеров, удаляет их по одному, вызывает `docker compose up -d --no-deps --no-recreate --scale api=2 api` и ожидает `healthy` новой реплики перед переходом к следующей. Флаг `--no-recreate` сохраняет работающий второй экземпляр. Compose может выдавать новым контейнерам следующие порядковые номера (`api-4`, `api-5` и т. д.), поэтому алгоритм не привязан к именам `api-1` и `api-2`. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Условия нагрузочного испытания: 90 секунд, конкурентность 4, закрытая модель нагрузки (closed-loop), создание сообщений через POST, без автоматических повторов на стороне нагрузочного клиента. + +| Метрика | Первый прогон | Повторный прогон после изменения Nginx | +| --- | ---: | ---: | +| Длительность | 90,018 с | 90,021 с | +| Успешные запросы | 34 594 | **35 685** | +| Неуспешные запросы | **5 661** | **0** | +| Доля ошибок | 14,0628% | **0%** | +| Успешных запросов/с | 384,301 | 396,409 | +| p50 успешных запросов | 8,035 мс | 8,014 мс | +| p95 успешных запросов | 25,285 мс | 25,782 мс | +| p99 успешных запросов | 39,950 мс | 39,431 мс | +| Замена двух реплик | PASS | PASS | + +**Разбор неудачного прогона.** В логах Nginx многократно появлялось `no live upstreams while connecting to upstream` для POST-запросов. Это показывает, что балансировщик в некоторые моменты не имел доступного upstream. После изменения upstream на `server api:8080 resolve max_fails=0;` повторный прогон завершился без зарегистрированных ошибок. Эксперимент подтверждает улучшение в измеренных условиях + +**Ограничение методики.** Перцентили вычисляются только по успешным запросам; ошибочные запросы учитываются отдельно. Closed-loop-нагрузка подвержена coordinated omission и накладным расходам клиента. Был проведён один повторный успешный прогон, а не три независимых повтора; поэтому статистическая воспроизводимость результата не установлена. Интервалы недоступности по секундам и CPU/RAM не замерялись. + +### 3.3. Миграции и совместимость схемы + +Сервис `migrate` выполняется как отдельная одноразовая задача, от успешного завершения которой зависит запуск API. Это отделяет изменение схемы от старта каждой реплики. `golang-migrate` отслеживает версии и состояние миграций; запрос к `schema_migrations` показал `version=2`, `dirty=false`. + +`0001_init` создаёт основные таблицы и индексы. `0002_idempotency` добавляет таблицу `message_idempotency` с уникальным составным ключом и индексом срока хранения, не удаляя существующие поля или таблицы. Это **добавочное изменение схемы**, потенциально совместимое с работающей предыдущей версией приложения. Однако совместная работа старой версии API с новой схемой **не проверялась экспериментально**, поэтому полной гарантии обратной совместимости нет. Для будущих несовместимых изменений требуется поэтапный подход expand–migrate–contract. + +Наличие `version=2, dirty=false` подтверждает завершённое состояние схемы, но само по себе не доказывает количество фактических запусков контейнера миграций. Одноразовость обеспечивается архитектурой Compose (`migrate` как отдельный job), а не приведённым SQL-запросом. + +## 4. Ограничения и риски + +1. **SPOF.** Один Nginx, один PostgreSQL и один Docker-хост остаются едиными точками отказа; отказ хоста или PostgreSQL не переживается автоматически. +2. **DNS и upstream.** При смене контейнеров возможны краткие ошибки до обновления DNS. `max_fails=0` отключает пассивное исключение неработающего адреса и имеет собственный компромисс: такой адрес может выбираться повторно. +3. **Границы rolling update.** Подтверждена последовательная замена контейнеров на текущем образе. Развёртывание новой версии образа и проверка совместимости двух разных версий приложения не проводились. +4. **Идемпотентность.** Ключи сохраняются на 24 часа и далее: автоматическая очистка истёкших записей пока отсутствует. Это не приводит к повторной записи при сохранённом ключе, но требует обслуживания таблицы и уточнения политики повторного использования ключей. +5. **Redis.** Redis не является источником истины для авторизации. Проверка PostgreSQL на каждом запросе упрощает корректность отзыва сессий, но добавляет нагрузку на БД и ограничивает масштабирование. +6. **Методика нагрузки.** Отсутствуют три независимых повтора успешного прогона, замеры CPU/RAM и точная временная диаграмма ошибок. Не следует утверждать, что система гарантирует zero downtime при любой нагрузке. +7. **Старые данные.** При использовании базы с несовместимым форматом служебной таблицы миграций может потребоваться отдельная процедура переноса; `docker compose down -v` удаляет данные и не является безопасным способом обновления рабочей БД. + +## 5. Источники, инструменты и использование ИИ + +Исходные требования и контракт курса: `contracts/openapi.json`, `contracts/README.md`, `contracts/infrastructure.json`. В проекте используются Go, `pgx/v5`, `golang-migrate/v4`, `go-redis/v9`, PostgreSQL, Redis, Nginx и Docker Compose. Для анализа реализации, диагностики ошибок Nginx, подготовки сценариев испытаний и оформления отчёта использовался ChatGPT. Команды и фактические результаты экспериментов проверялись на Docker-хосте автором работы. Данные измерений не подменялись оценками ИИ. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..e69219a0 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,70 @@ +services: + postgres: + image: postgres:16.4-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: [postgres_password] + volumes: [pgdata:/var/lib/postgresql/data] + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 3s + timeout: 2s + retries: 20 + mem_limit: 512m + cpus: 1.0 + restart: unless-stopped + redis: + image: redis:7.4.1-alpine + command: ["redis-server", "--save", "", "--appendonly", "no"] + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 3s + timeout: 2s + retries: 20 + mem_limit: 128m + cpus: 0.5 + restart: unless-stopped + migrate: + build: {context: ., dockerfile: Dockerfile} + entrypoint: ["/app/messenger", "-migrate"] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: [database_url] + depends_on: + postgres: {condition: service_healthy} + restart: "no" + api: + build: {context: ., dockerfile: Dockerfile} + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: docker + SESSION_TTL_SECONDS: "3600" + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + secrets: [database_url, cache_url] + depends_on: + migrate: {condition: service_completed_successfully} + redis: {condition: service_healthy} + mem_limit: 256m + cpus: 0.75 + stop_grace_period: 10s + restart: unless-stopped + lb: + image: nginx:1.27.5-alpine + volumes: + - ./infra/nginx.conf:/etc/nginx/nginx.conf:ro + ports: ["127.0.0.1:8080:8080"] + depends_on: + api: {condition: service_healthy} + mem_limit: 128m + cpus: 0.5 + restart: unless-stopped +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/evidence/load.json b/evidence/load.json new file mode 100644 index 00000000..b38d81a9 --- /dev/null +++ b/evidence/load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.021, + "concurrency": 4, + "successful_requests": 11816, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 393.589, + "successful_latency_ms": { + "p50": 7.992, + "p95": 27.642, + "p99": 46.719 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} 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..44e41deb --- /dev/null +++ b/evidence/make_test.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/make_validate.txt b/evidence/make_validate.txt new file mode 100644 index 00000000..683be253 --- /dev/null +++ b/evidence/make_validate.txt @@ -0,0 +1,2 @@ +python3 scripts/validate_openapi.py +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. diff --git a/evidence/migrations.txt b/evidence/migrations.txt new file mode 100644 index 00000000..5c19b407 --- /dev/null +++ b/evidence/migrations.txt @@ -0,0 +1,5 @@ + version | dirty +---------+------- + 2 | f +(1 row) + diff --git a/evidence/rolling-load.json b/evidence/rolling-load.json new file mode 100644 index 00000000..396738d0 --- /dev/null +++ b/evidence/rolling-load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 90.0, + "elapsed_seconds": 90.021, + "concurrency": 4, + "successful_requests": 35685, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 396.409, + "successful_latency_ms": { + "p50": 8.014, + "p95": 25.782, + "p99": 39.431 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/test_failover.txt b/evidence/test_failover.txt new file mode 100644 index 00000000..2e70057e --- /dev/null +++ b/evidence/test_failover.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 106, "failed_attempts": 1, "first_recovery_seconds": 1.517} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. 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/infra/nginx.conf b/infra/nginx.conf new file mode 100644 index 00000000..16e2ecec --- /dev/null +++ b/infra/nginx.conf @@ -0,0 +1,26 @@ +events { worker_connections 1024; } +http { + access_log /dev/stdout; + error_log /dev/stderr warn; + resolver 127.0.0.11 valid=2s ipv6=off; + upstream api_backends { + zone api_backends 64k; + server api:8080 resolve max_fails=0; + keepalive 16; + } + server { + listen 8080; + location / { + proxy_pass http://api_backends; + proxy_http_version 1.1; + proxy_set_header Connection ""; + proxy_set_header Host $host; + proxy_connect_timeout 1s; + proxy_read_timeout 12s; + proxy_send_timeout 12s; + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + # POST is not transparently retried: client uses Idempotency-Key. + } + } +} diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 00000000..3e9da926 --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,10 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +mkdir -p secrets +if [ -e secrets/postgres_password.txt ]; then echo 'Secrets already exist; leaving unchanged'; exit 0; fi +password=$(od -An -N24 -tx1 /dev/urandom | tr -d ' \n') +printf '%s' "$password" > secrets/postgres_password.txt +printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' "$password" > secrets/database_url.txt +printf '%s' 'redis://redis:6379/0' > secrets/cache_url.txt +chmod 600 secrets/*.txt diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..eb43e448 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose down +docker compose up -d --scale api=2 --build --wait diff --git a/scripts/restore.sh b/scripts/restore.sh new file mode 100755 index 00000000..f8ce5cdf --- /dev/null +++ b/scripts/restore.sh @@ -0,0 +1,8 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose up -d --scale api=2 --no-recreate api +# Explicitly start any stopped API container (Compose does not necessarily do so). +for id in $(docker compose ps -a -q api); do + if [ "$(docker inspect --format '{{.State.Running}}' "$id")" = false ]; then docker start "$id" >/dev/null; fi +done diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..4cd9b26d --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,71 @@ + +#!/usr/bin/env bash +set -euo pipefail + +cd "$(dirname "$0")/.." + +# Запоминаем именно исходные контейнеры. +mapfile -t old_ids < <(docker compose ps -q api) + +if [[ "${#old_ids[@]}" -ne 2 ]]; then + echo "ERROR: expected exactly two API replicas" + exit 1 +fi + +wait_healthy() { + local id="$1" + local deadline=$((SECONDS + 60)) + local status="" + + while (( SECONDS < deadline )); do + status=$(docker inspect \ + -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' \ + "$id" 2>/dev/null || true) + + if [[ "$status" == "healthy" ]]; then + return 0 + fi + + sleep 1 + done + + echo "ERROR: container $id did not become healthy" + return 1 +} + +for old_id in "${old_ids[@]}"; do + echo "Replacing $old_id..." + + docker stop --timeout 10 "$old_id" + docker rm "$old_id" + + docker compose up -d \ + --no-deps \ + --no-recreate \ + --scale api=2 \ + api + + mapfile -t current_ids < <(docker compose ps -q api) + + if [[ "${#current_ids[@]}" -ne 2 ]]; then + echo "ERROR: expected two API replicas after replacement" + exit 1 + fi + + new_id="" + for id in "${current_ids[@]}"; do + if [[ "$id" != "${old_ids[0]}" && "$id" != "${old_ids[1]}" ]]; then + new_id="$id" + fi + done + + if [[ -z "$new_id" ]]; then + echo "ERROR: new API replica not found" + exit 1 + fi + + wait_healthy "$new_id" + echo "New replica $new_id is healthy" +done + +echo "PASS: sequential API replica replacement completed" diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..023b6e05 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,14 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +: "${TARGET_INSTANCE_ID:?test provides instance alias}" +# Default Docker hostname is the container's short ID, used as X-Instance-Id. +for id in $(docker compose ps -q api); do + hostname=$(docker inspect --format '{{.Config.Hostname}}' "$id") + if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then + docker stop --time 2 "$id" >/dev/null + exit 0 + fi +done +printf '%s\n' 'No running API container matches TARGET_INSTANCE_ID' >&2 +exit 1 diff --git a/src/api_test.go b/src/api_test.go new file mode 100644 index 00000000..ee512433 --- /dev/null +++ b/src/api_test.go @@ -0,0 +1,1127 @@ +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) + } + if method == "POST" && strings.HasSuffix(path, "/messages") && req.Header.Get("Idempotency-Key") == "" { + req.Header.Set("Idempotency-Key", newUUID()) + } + 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) +} + +// Concurrent requests from two independent HTTP servers must produce one row. +func TestLab3IdempotencyAcrossReplicas(t *testing.T) { + e := newTestEnv(t) + alice := e.mustActor("alice") + chat := e.mustChat(alice, "shared") + second := httptest.NewServer((&api{store: NewStore(sharedDB, nil, time.Hour)}).routes()) + defer second.Close() + path := "/api/v1/chats/" + chat.ID + "/messages" + key := newUUID() + var wg sync.WaitGroup + ids := make(chan string, 20) + errs := make(chan error, 20) + for i := 0; i < 20; i++ { + wg.Add(1) + go func(i int) { + defer wg.Done() + base := e.url + if i%2 == 1 { + base = second.URL + } + body := strings.NewReader(`{"text":"same"}`) + req, err := http.NewRequest("POST", base+path, body) + if err != nil { + errs <- err + return + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Authorization", "Bearer "+alice.token) + req.Header.Set("Idempotency-Key", key) + resp, err := http.DefaultClient.Do(req) + if err != nil { + errs <- err + return + } + defer resp.Body.Close() + var m Message + if resp.StatusCode != 201 { + errs <- fmt.Errorf("status %d", resp.StatusCode) + return + } + if err := json.NewDecoder(resp.Body).Decode(&m); err != nil { + errs <- err + return + } + ids <- m.ID + }(i) + } + wg.Wait() + close(errs) + close(ids) + for err := range errs { + t.Error(err) + } + first := "" + n := 0 + for id := range ids { + n++ + if first == "" { + first = id + } + if id != first { + t.Errorf("different messages: %s != %s", id, first) + } + } + if n != 20 { + t.Fatalf("successful responses %d/20", n) + } + items, _ := e.listMessages(alice, chat.ID, 100) + if len(items) != 1 { + t.Fatalf("expected one message, got %d", len(items)) + } +} 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..822972ce --- /dev/null +++ b/src/handlers.go @@ -0,0 +1,430 @@ +package main + +import ( + "context" + "errors" + "io" + "net" + "net/http" + "regexp" + "strconv" + "strings" + "sync/atomic" + + "github.com/jackc/pgx/v5/pgconn" +) + +type api struct { + store *Store + draining *atomic.Bool +} + +var idempotencyKeyRE = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`) + +// 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 a.draining != nil && a.draining.Load() { + writeError(w, 503, "unavailable", "API завершает работу") + return + } + 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 + } + key := r.Header.Get("Idempotency-Key") + if !idempotencyKeyRE.MatchString(key) { + badRequest(w, "Требуется корректный Idempotency-Key") + return + } + var req struct { + Text string `json:"text"` + AttachmentIDs []string `json:"attachment_ids"` + } + if !decodeJSON(w, r, &req) { + return + } + if len(req.AttachmentIDs) > 0 { + badRequest(w, "Вложения доступны с лабораторной 4") + return + } + if !validText(req.Text, 4000) { + badRequest(w, "text должен содержать от 1 до 4000 символов и не состоять из пробелов") + return + } + m, err := a.store.AddMessageIdempotent(r.Context(), me.ID, id, key, req.Text) + if errors.Is(err, errNotFound) { + writeError(w, 404, "not_found", "Чат не найден") + return + } + if errors.Is(err, errConflict) { + writeError(w, 409, "conflict", "Ключ уже использован с другим содержимым") + 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..f536f501 --- /dev/null +++ b/src/httpx.go @@ -0,0 +1,232 @@ +package main + +import ( + "bytes" + "crypto/rand" + "encoding/json" + "errors" + "fmt" + "io" + "log/slog" + "mime" + "net/http" + "os" + "reflect" + "regexp" + "runtime/debug" + "strings" + "time" + "unicode/utf8" +) + +var instanceID = func() string { + if v := env("INSTANCE_ID", ""); v != "" { + return v + } + if h, e := os.Hostname(); e == nil { + return h + } + return newUUID() +}() + +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) + w.Header().Set("X-Instance-Id", instanceID) + 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..8b8df637 --- /dev/null +++ b/src/main.go @@ -0,0 +1,157 @@ +package main + +import ( + "context" + "flag" + "log/slog" + "net" + "net/http" + "os" + "os/signal" + "strconv" + "strings" + "sync/atomic" + "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() { + migrate := flag.Bool("migrate", false, "применить миграции и завершиться") + 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") + if *migrate { + if err := runMigrations(dsn); err != nil { + slog.Error("migrations failed", "err", err) + os.Exit(1) + } + return + } + + // Миграции выполняет только отдельный one-shot сервис migrate. + // Для локальной отладки: messenger -migrate. + + 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) + var draining atomic.Bool + + srv := &http.Server{ + Addr: net.JoinHostPort(host, port), + Handler: (&api{store: store, draining: &draining}).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. + draining.Store(true) + 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") +} 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/migrations/0002_idempotency.down.sql b/src/migrations/0002_idempotency.down.sql new file mode 100644 index 00000000..21f1ca27 --- /dev/null +++ b/src/migrations/0002_idempotency.down.sql @@ -0,0 +1 @@ +DROP TABLE IF EXISTS message_idempotency; diff --git a/src/migrations/0002_idempotency.up.sql b/src/migrations/0002_idempotency.up.sql new file mode 100644 index 00000000..0f443856 --- /dev/null +++ b/src/migrations/0002_idempotency.up.sql @@ -0,0 +1,7 @@ +CREATE TABLE message_idempotency ( + user_id uuid NOT NULL REFERENCES users(id), chat_id uuid NOT NULL REFERENCES chats(id), + key text NOT NULL, body_fingerprint text NOT NULL, + message_id uuid REFERENCES messages(id), expires_at timestamptz NOT NULL, + PRIMARY KEY(user_id,chat_id,key) +); +CREATE INDEX message_idempotency_expiry_idx ON message_idempotency(expires_at); diff --git a/src/store.go b/src/store.go new file mode 100644 index 00000000..bdcc8758 --- /dev/null +++ b/src/store.go @@ -0,0 +1,636 @@ +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 + } + // Avoid caching positive auth decisions across replicas. + _ = 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) + + // Multi-replica correctness: never trust a positive Redis cache hit. + // PostgreSQL is authoritative for revocation on every request. + + 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) + // Avoid caching positive auth decisions across replicas. + _ = 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 + } + // All replicas check PostgreSQL, so a failed Redis DEL cannot resurrect a token. + _ = s.cache.invalidate(ctx, hash, 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 +} + + +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 +} + + +func (s *Store) AddMessageIdempotent(parent context.Context, userID, chatID, key, body string) (Message, error) { + ctx, cancel := context.WithTimeout(parent, 8*time.Second) + defer cancel() + tx, err := s.db.Begin(ctx) + if err != nil { + return Message{}, err + } + defer tx.Rollback(ctx) + var member bool + if err = tx.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2)`, chatID, userID).Scan(&member); err != nil { + return Message{}, err + } + if !member { + return Message{}, errNotFound + } + // The request fingerprint is canonical for lab3: text plus the normalized empty attachment list. + fingerprint := body + var existingID *string + var oldFingerprint string + err = tx.QueryRow(ctx, `INSERT INTO message_idempotency (user_id,chat_id,key,body_fingerprint,message_id,expires_at) + VALUES ($1,$2,$3,$4,NULL,now()+interval '24 hours') + ON CONFLICT (user_id,chat_id,key) DO UPDATE SET key=EXCLUDED.key + RETURNING message_id,body_fingerprint`, userID, chatID, key, fingerprint).Scan(&existingID, &oldFingerprint) + if err != nil { + return Message{}, err + } + if oldFingerprint != fingerprint { + return Message{}, errConflict + } + if existingID != nil { + var m Message + var t time.Time + err = tx.QueryRow(ctx, `SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE id=$1`, *existingID).Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &t) + if err != nil { + return Message{}, err + } + m.CreatedAt = formatTS(t) + if err = tx.Commit(ctx); err != nil { + return Message{}, err + } + return m, nil + } + m := Message{ID: newUUID(), ChatID: chatID, SenderID: userID, Text: body} + var t time.Time + err = tx.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, body).Scan(&t) + if err != nil { + return Message{}, err + } + m.CreatedAt = formatTS(t) + _, err = tx.Exec(ctx, `UPDATE message_idempotency SET message_id=$4 WHERE user_id=$1 AND chat_id=$2 AND key=$3`, userID, chatID, key, m.ID) + if err != nil { + return Message{}, err + } + if err = tx.Commit(ctx); err != nil { + return Message{}, err + } + return m, nil +} diff --git a/tests/idempotency_concurrent.py b/tests/idempotency_concurrent.py new file mode 100644 index 00000000..dd55f27c --- /dev/null +++ b/tests/idempotency_concurrent.py @@ -0,0 +1,78 @@ +"""Concurrent Idempotency-Key test for lab 3.""" + +from concurrent.futures import ThreadPoolExecutor +import threading +import uuid + +from client import Client, Failure, arguments, check, run + + +def main(): + args = arguments("Concurrent idempotency test") + client = Client(args.base_url, args.ca_file) + + alice, bob, eve, chat = client.bootstrap() + + key = uuid.uuid4().hex + message_text = "concurrent-idempotency-" + uuid.uuid4().hex + path = f"/api/v1/chats/{chat['id']}/messages" + + workers = 20 + barrier = threading.Barrier(workers) + + def send(_): + local = Client(args.base_url, args.ca_file, timeout=10) + barrier.wait() + + response = local.message( + alice, + chat, + message_text, + key=key, + ) + + return { + "id": response["json"]["id"], + "instance": response["headers"].get("X-Instance-Id"), + "message": response["json"], + } + + with ThreadPoolExecutor(max_workers=workers) as executor: + results = list(executor.map(send, range(workers))) + + ids = {r["id"] for r in results} + instances = {r["instance"] for r in results if r["instance"]} + + print(f"Concurrent requests: {workers}") + print(f"Unique message IDs: {len(ids)}") + print(f"Observed API instances: {len(instances)}") + print(f"Instance IDs: {sorted(instances)}") + + check(len(ids) == 1, "duplicate messages were created") + check( + all(r["message"] == results[0]["message"] for r in results), + "idempotency responses differ", + ) + check(len(instances) >= 2, "requests did not reach two API instances") + + # Verify that the stored chat history contains exactly one copy. + history = client.call( + "GET", + path + "?limit=100", + actor=alice, + schema="MessagePage", + )["json"] + + matches = [ + item for item in history["items"] + if item["text"] == message_text + ] + + check(len(matches) == 1, "chat history contains duplicate messages") + check(matches[0]["id"] in ids, "stored message ID differs") + + print("PASS: concurrent idempotency across API replicas") + + +if __name__ == "__main__": + run(main)