diff --git a/.dockerignore b/.dockerignore index bc16e556..94f7c95a 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,12 @@ __pycache__ node_modules evidence .DS_Store +bin +coverage +*.out +*.test +**/*_test.go +cmd/*_test.go +internal/api/*_test.go +internal/store/*_test.go +internal/config/*_test.go diff --git a/.env.example b/.env.example index 714c8076..14c738a2 100644 --- a/.env.example +++ b/.env.example @@ -3,9 +3,22 @@ APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab +# SIGTERM budget. Must stay within 1..10 seconds. +SHUTDOWN_TIMEOUT_SECONDS=8 + +# Скопируйте в .env и замените пароли. Файл .env не коммитится. +# Пароли — локальные синтетические, без символов @ : / # пробела: они ломают URL. +POSTGRES_USER=messenger +POSTGRES_PASSWORD=replace-with-local-secret +POSTGRES_DB=messenger +# С хоста (тесты, psql). В контейнере API адрес переопределяет compose.yaml. +DATABASE_URL=postgres://messenger:replace-with-local-secret@127.0.0.1:5432/messenger?sslmode=disable +REDIS_PASSWORD=replace-with-local-redis-secret +REDIS_URL=redis://:replace-with-local-redis-secret@127.0.0.1:6379/0 +# Для make test держите не меньше 300. Короткий TTL — только отдельный прогон expiry. SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +DB_MAX_CONNS=10 +# Argon2id: время, память в KiB, потоки. OWASP-ориентир m=19456 t=2 p=1. +ARGON2_TIME=2 +ARGON2_MEMORY_KIB=19456 +ARGON2_THREADS=1 diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 8ceefa10..04e6122f 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,18 @@ ## Лабораторная 2 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Колмычков Иван Сергеевич, БВТ2303 +Целевая оценка (3/4/5): 5 +Трек 5, если заявлен: 2. План запроса и восстановление. -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Что реализовано и что перенесено: in-memory API лабораторной 1 перенесён в PostgreSQL. Регистрация с паролем, Basic только на создании сессии, дальше opaque Bearer. Чаты создаются одной транзакцией. Redis хранит сессии до абсолютного expires_at. +Команды запуска из чистого clone: см. REPORT.md, раздел «Запуск из чистого clone» +Результаты проверок и ссылка на REPORT.md: make check, make test, make test-persistence, go test, scripts/check_dependencies.sh и scripts/track2_experiment.sh — PASS. Цифры в REPORT.md и evidence/ +Ограничения / известные ошибки: один Docker-host; AOF everysec может потерять около секунды новых сессий при жёстком убийстве Redis; dump не содержит сессий; разница стоимости записи двух индексов на 5000 строк в одном прогоне неразличима +Источники и использование ИИ: pgx, go-redis, golang.org/x/crypto/argon2, документация PostgreSQL и Redis. Нейросети помогали с написанием кода, написанием отчета, написанием тестов. -- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. -- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. +- [x] Контракт и публичные тесты не ослаблены. +- [x] make check и make test выполнены; приложен реальный вывод. +- [x] Сценарии отказов/безопасности своего уровня воспроизведены. +- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. +- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..604d58f6 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,22 @@ +FROM golang:1.26-bookworm AS build +WORKDIR /src +COPY go.mod go.sum ./ +RUN go mod download +COPY messenger ./messenger +COPY internal ./internal +COPY migrations ./migrations +RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \ + go build -trimpath -ldflags='-s -w' -o /out/messenger ./messenger \ + && chmod 755 /out/messenger + +FROM gcr.io/distroless/static-debian12:nonroot@sha256:afa5c872c891853ca7fcf1f12c3edb23f7eeef36189728842dd51042ff57f7ab +COPY --from=build --chown=65532:65532 /out/messenger /messenger +USER 65532:65532 +ENV APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab \ + SHUTDOWN_TIMEOUT_SECONDS=8 +EXPOSE 8080 +HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=3 \ + CMD ["/messenger", "healthcheck"] +ENTRYPOINT ["/messenger"] diff --git a/Makefile b/Makefile index 9ecb223e..02f133b4 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,10 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-own test-persistence help: - @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes; test-own: Go tests" check: $(PYTHON) scripts/check_contract.py @@ -21,6 +21,9 @@ test: load: $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) +test-own: + go test ./... + test-persistence: - @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) - $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + test -n "$(ACTION_SCRIPT)" + $(PYTHON) tests/resilience.py --base-url "$(BASE_URL)" --mode persistence --action-script "$(ACTION_SCRIPT)" $(TLS_ARGS) diff --git a/REPORT.md b/REPORT.md index e42f2b05..705a7c8d 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,108 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Колмычков Иван Сергеевич, БВТ2303 +- Целевая оценка; выбранный трек 5: 5, трек 2 «план запроса и восстановление». Сессии — Redis +- Commit/PR: +- Использованные источники, библиотеки и помощь ИИ: PostgreSQL 16 (транзакции, EXPLAIN), Redis AOF, RFC 7617, `jackc/pgx/v5`, `redis/go-redis/v9`, `golang.org/x/crypto/argon2`. Нейросети помогали с написанием кода, написанием отчета, проверки качества кода. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker с Compose, Go 1.26 (для `go test`) и Python 3.9+. Образы: `golang:1.26-bookworm` только на сборке, runtime — distroless static из [Dockerfile](Dockerfile), `postgres:16.10-bookworm`, `redis:7.4.6-alpine`. Стенд, на котором сняты цифры: Linux 7.0.0-31-generic x86_64, 8 CPU, MemTotal 7 381 312 KiB. Лимиты CPU/RAM контейнерам не задавались. + +```sh +cp .env.example .env +# в .env заменить пароли на локальные, без символов @ : / # и пробела +docker compose --env-file .env down -v # Чтобы был пустой volume +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +# дождаться, пока curl -sf http://127.0.0.1:8080/health/ready вернёт 200 +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +Миграции применяет сам API при старте. Повторный старт не вставляет строки заново: версия файла лежит в `schema_migrations`. + +Остановка без удаления данных: `docker compose --env-file .env stop`. +Удаление учебных volumes, только если данные больше не нужны: `docker compose --env-file .env down -v`. + +`SESSION_TTL_SECONDS` для smoke и persistence держать не меньше 300. Короткий TTL проверяется тестом `TestSessionExpires` (2 секунды) и интеграционным тестом Redis. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент ходит в один API. Пользователи, чаты, участники и сообщения живут в PostgreSQL: это источник истины. Сессии живут только в Redis. Файл `.env` задаёт `DATABASE_URL` и `REDIS_URL` для команд с хоста. Контейнер API получает те же пароли, но хосты `postgres` и `redis` — это переопределение в [compose.yaml](compose.yaml). + +```text +клиент → API → PostgreSQL (users, chats, chat_members, messages) + → Redis (ключ sess:, TTL до expires_at, AOF) +``` + +Пароль при регистрации превращается в Argon2id (`m=19456`, `t=2`, `p=1`, соль 16 байт). В JSON пользователя хеша нет. SHA-256 для пароля не используется: он слишком быстрый для перебора. bcrypt не используется: типичная реализация режет пароль до 72 байт. + +Токен сессии — 32 случайных байта (256 бит), клиент видит его один раз. В Redis лежит хеш токена и абсолютный `expires_at`. TTL ключа равен остатку до этого момента. Рестарт Redis его не сдвигает. AOF включён (`appendonly yes`, `appendfsync everysec`, RDB-преамбула). Одного TTL без диска было бы мало: после рестарта ключ исчез бы. `docker compose restart` шлёт SIGTERM процессу Redis (`exec` в команде), и Redis успевает дописать AOF. + +`POST /api/v1/auth/sessions` принимает только Basic. Остальные методы — только Bearer. `X-User-Id` не читается. Чужой чат для участника системы — 404, не 403: по ответу не видно, существует ли чат. + +Создание чата — одна транзакция: вставка чата и всех участников, затем COMMIT. Если участника нет, транзакция откатывается, строка чата не остаётся. Сообщение тоже пишется в транзакции. Строка чата берётся `FOR UPDATE`, чтобы два писателя одного чата не получили одно и то же `created_at`. Порядок истории — `(created_at, id)`. + +Пул: не больше 10 соединений, `statement_timeout=5s`, `lock_timeout=3s`. Запросы с `$1`, без склейки SQL. + +`/health/live` отвечает за процесс. `/health/ready` — 200, только если отвечают и PostgreSQL, и Redis. Если хранилище недоступно, запрос с Bearer получает 503. Запрос без Bearer получает 401 и до хранилища не доходит: аноним не становится пользователем из-за падения Redis. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | +| Публичный smoke | `make test` | PASS lab2 | [evidence/smoke.txt](evidence/smoke.txt) | +| Контракт на месте | `make check` | PASS | [evidence/check.txt](evidence/check.txt) | +| Данные и сессия переживают рестарт API, PostgreSQL и Redis | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS. StartedAt всех трёх контейнеров сменился, volumes не удалялись | [evidence/persistence.txt](evidence/persistence.txt) | +| Миграция повторно не плодит строки | `go test ./internal/store/ -run TestIntegrationMigrationRerunKeepsRows` | PASS при заданном `DATABASE_URL` | [evidence/go_migration.txt](evidence/go_migration.txt) | +| Гонка одного username | `TestIntegrationUsernameRace`, 32 параллельных INSERT | ровно один успех, остальные `ErrConflict` | [evidence/go_username_race.txt](evidence/go_username_race.txt) | +| Откат создания чата | `TestIntegrationChatRollback` | число `chats` и `chat_members` не выросло | [evidence/go_chat_rollback.txt](evidence/go_chat_rollback.txt) | +| Неверный пароль, logout, `X-User-Id` | `go test ./internal/api/ -run TestSessionWrongPasswordLogoutAndIgnoredUserHeader` | 401 с Basic или Bearer, logout 204, затем 401, чужой `X-User-Id` не меняет `/users/me` | [evidence/go_session_auth.txt](evidence/go_session_auth.txt) | +| Короткий TTL | `go test ./internal/api/ -run TestSessionExpires` (2 с) и go test ./internal/session/ -run`TestIntegrationRedisRoundTrip` | тот же токен после паузы даёт 401 / `ErrNotFound` | [evidence/go_session_ttl.txt](evidence/go_session_ttl.txt), [evidence/go_redis_ttl.txt](evidence/go_redis_ttl.txt) | +| Redis или БД недоступны | `./scripts/check_dependencies.sh` | live 200, ready 503, без заголовка 401, с живым Bearer 503; после старта PostgreSQL тот же Bearer снова 200 | [evidence/dependencies.txt](evidence/dependencies.txt) | +| AOF реально включён | `INFO persistence` внутри Redis | `aof_enabled:1`, `aof_last_write_status:ok` | [evidence/redis_persistence.txt](evidence/redis_persistence.txt) | +| Индекс истории на ≥10 000 сообщений | `./scripts/track2_experiment.sh`, чат `big` = 80 000 при 100 000 в таблице | без индекса Parallel Seq Scan, 14.356 ms, 1248 buffers, 30 000 отброшенных строк на воркер. С `messages_history_idx` Index Scan, 0.063 ms, buffers hit=2 read=3, лишние строки не отбрасываются | [evidence/track2_explain.txt](evidence/track2_explain.txt) | + + + ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Гипотеза трека 2: страница истории по `(created_at, id)` внутри одного чата должна читаться индексом `(chat_id, created_at, id)`. Индекс только по `(created_at, id)` для редкого чата просматривает чужие строки. Цена записи у двух индексов на 5 000 строк близка. Логический dump сохраняет зафиксированные строки и не включает сессии. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Методика, всё в `./scripts/track2_experiment.sh`. База `messenger_bench` отдельно от рабочей `messenger`. 100 000 сообщений: чат `big` 80 000, `mid` 15 000, `small` 4 000, 100 коротких чатов по 10. Времена сообщений перемешаны, иначе индекс по времени читает сплошной кусок одного чата. Один и тот же keyset: 50 строк после середины большого чата. Сравнение: нет вторичного индекса, индекс `(created_at, id)`, индекс `(chat_id, created_at, id)`. Запись: 5 000 строк при каждом индексе, затем эти строки удаляются, чтобы dump содержал исходные 100 000. Дальше `pg_dump -Fc`, новая база `messenger_restore`, `pg_restore`, сверка количеств и текстов `big-1`, `big-80000`, `mid-15000`, образца короткого чата. + +Наблюдение на этом стенде: + +- Seq Scan большого чата: 14.356 ms, 1248 shared buffers, фильтр снимает 30 000 строк на каждом из двух воркеров. +- Индекс только по времени, большой чат: 0.062 ms. Следующие 50 строк и так его, фильтр почти ничего не выкидывает. +- Индекс только по времени, чат `small`: 0.282 ms, 1245 строк снято фильтром, 57+6 buffers. +- Индекс истории, большой чат: 0.063 ms, 2+3 buffers, условие сразу содержит `chat_id`. +- Индекс истории, чат `small`: 0.072 ms, 3+2 buffers, снятых фильтром строк нет. +- Вставка 5 000 строк: 107.113 ms с индексом по времени и 104.827 ms с индексом истории. Одного прогона мало, чтобы объявить индекс истории дороже на записи. Выигрыш виден на чтении редкого чата. +- `pg_dump` 512 ms, `pg_restore` 604 ms. Сверка совпала: 100 000 сообщений, 104 чата, 1 пользователь. `synchronous_commit=on`. + + +| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| --------------------------------------------------------------- | -------------------------------------------------- | ----------------------------------------- | --------------------------------------------------------------- | +| `scripts/restart.sh` (API, PostgreSQL, Redis, volumes на месте) | тот же Bearer читает те же сообщения | PASS persistence | контейнеры поднялись за секунды, подтверждённые строки на месте | +| `stop redis` | live 200, ready 503, без токена 401, с токеном 503 | так и есть | после `start` ready снова 200 | +| `stop postgres` | живой Bearer не обслуживается, пока нет БД | 503, после старта тот же Bearer снова 200 | данные пользователя пережили остановку | +| `pg_dump` → новая база | те же количества и выбранные тексты | `compare=match` | dump 512 ms, restore 604 ms. Сессий в dump нет | + + +Прогрев перед EXPLAIN — `ANALYZE`. Нагрузка трека — один проход вставки и по одному `EXPLAIN (ANALYZE, BUFFERS)`, не серия RPS. Публичный `tests/load.py` здесь не использовался как оценка пропускной способности: это closed-loop одного клиента. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +`synchronous_commit=on` означает, что COMMIT возвращается после записи WAL на диск с точки зрения PostgreSQL. Если сам диск подтверждает запись раньше, чем она оказалась в энергонезависимой памяти, эту дыру стенд не закрывает. Падение до COMMIT теряет только незавершённую транзакцию. + +Dump — снимок на момент старта `pg_dump`. Коммиты, пришедшие после начала снимка, в файл не входят. Восстановление в новую базу не подменяет Redis: сессии восстанавливает AOF. При `appendfsync everysec` жёсткое убийство Redis может потерять около секунды новых сессий. Сообщения при этом остаются в PostgreSQL. + +Один Docker-host не переживает потерю этой машины. Несколько контейнеров не делают базу высокодоступной. + +Индекс истории оставлен в миграции, потому что страница API — это `WHERE chat_id = $1 AND (created_at, id) > cursor ORDER BY created_at, id LIMIT n`. На редком чате индекс только по времени читает чужие строки. На плотном чате разница во времени маленькая, зато seq scan читает всю таблицу. + +Argon2id с этими параметрами — учебный компромисс скорости smoke и стойкости. \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..c7cc885d --- /dev/null +++ b/compose.yaml @@ -0,0 +1,82 @@ +# Локальный стенд лабораторной 2. Секреты только из .env, volumes не удаляются restart-скриптом. +name: messenger-lab2 + +services: + postgres: + image: postgres:16.10-bookworm + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: ${POSTGRES_DB} + command: + - postgres + - -c + - synchronous_commit=on + - -c + - max_connections=50 + volumes: + - pgdata:/var/lib/postgresql/data + ports: + - "127.0.0.1:5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 5s + restart: unless-stopped + + redis: + image: redis:7.4.6-alpine + environment: + REDIS_PASSWORD: ${REDIS_PASSWORD} + # exec нужен, чтобы SIGTERM пришёл самому Redis и он дописал AOF перед выходом. + command: + - sh + - -c + - exec redis-server --appendonly yes --appendfsync everysec --aof-use-rdb-preamble yes --dir /data --requirepass "$$REDIS_PASSWORD" --bind 0.0.0.0 --protected-mode yes + volumes: + - redisdata:/data + ports: + - "127.0.0.1:6379:6379" + healthcheck: + test: ["CMD-SHELL", "redis-cli --no-auth-warning -a \"$$REDIS_PASSWORD\" ping | grep -q PONG"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 3s + restart: unless-stopped + + api: + build: . + image: messenger-api:lab2 + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: lab + SHUTDOWN_TIMEOUT_SECONDS: ${SHUTDOWN_TIMEOUT_SECONDS:-8} + DATABASE_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}?sslmode=disable + REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DB_MAX_CONNS: ${DB_MAX_CONNS:-10} + ARGON2_TIME: ${ARGON2_TIME:-2} + ARGON2_MEMORY_KIB: ${ARGON2_MEMORY_KIB:-19456} + ARGON2_THREADS: ${ARGON2_THREADS:-1} + ports: + - "127.0.0.1:8080:8080" + healthcheck: + test: ["CMD", "/messenger", "healthcheck"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 10s + restart: unless-stopped + +volumes: + pgdata: + redisdata: diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 00000000..9a553306 --- /dev/null +++ b/evidence/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/dependencies.txt b/evidence/dependencies.txt new file mode 100644 index 00000000..d3f19498 --- /dev/null +++ b/evidence/dependencies.txt @@ -0,0 +1,14 @@ +stop redis +live_redis_down 200 +ready_redis_down 503 +anon_redis_down 401 +bearer_redis_down 503 +start redis +stop postgres +live_pg_down 200 +ready_pg_down 503 +anon_pg_down 401 +bearer_pg_down 503 +start postgres +bearer_after 200 +PASS dependencies diff --git a/evidence/go test.txt b/evidence/go test.txt new file mode 100644 index 00000000..49a2d3f3 --- /dev/null +++ b/evidence/go test.txt @@ -0,0 +1 @@ +ok messenger/internal/store 0.006s \ No newline at end of file diff --git a/evidence/go_chat_rollback.txt b/evidence/go_chat_rollback.txt new file mode 100644 index 00000000..533dcd9e --- /dev/null +++ b/evidence/go_chat_rollback.txt @@ -0,0 +1,4 @@ +=== RUN TestIntegrationChatRollback +--- PASS: TestIntegrationChatRollback (0.02s) +PASS +ok messenger/internal/store 0.030s diff --git a/evidence/go_migration.txt b/evidence/go_migration.txt new file mode 100644 index 00000000..171f3879 --- /dev/null +++ b/evidence/go_migration.txt @@ -0,0 +1,4 @@ +=== RUN TestIntegrationMigrationRerunKeepsRows +--- PASS: TestIntegrationMigrationRerunKeepsRows (0.02s) +PASS +ok messenger/internal/store 0.028s diff --git a/evidence/go_redis_ttl.txt b/evidence/go_redis_ttl.txt new file mode 100644 index 00000000..50486e0b --- /dev/null +++ b/evidence/go_redis_ttl.txt @@ -0,0 +1,4 @@ +=== RUN TestIntegrationRedisRoundTrip +--- PASS: TestIntegrationRedisRoundTrip (2.21s) +PASS +ok messenger/internal/session 2.214s diff --git a/evidence/go_session_auth.txt b/evidence/go_session_auth.txt new file mode 100644 index 00000000..e9c93419 --- /dev/null +++ b/evidence/go_session_auth.txt @@ -0,0 +1,4 @@ +=== RUN TestSessionWrongPasswordLogoutAndIgnoredUserHeader +--- PASS: TestSessionWrongPasswordLogoutAndIgnoredUserHeader (0.01s) +PASS +ok messenger/internal/api 0.012s diff --git a/evidence/go_session_ttl.txt b/evidence/go_session_ttl.txt new file mode 100644 index 00000000..b284e975 --- /dev/null +++ b/evidence/go_session_ttl.txt @@ -0,0 +1,4 @@ +=== RUN TestSessionExpires +--- PASS: TestSessionExpires (2.10s) +PASS +ok messenger/internal/api 2.109s diff --git a/evidence/go_username_race.txt b/evidence/go_username_race.txt new file mode 100644 index 00000000..469fe35e --- /dev/null +++ b/evidence/go_username_race.txt @@ -0,0 +1,4 @@ +=== RUN TestIntegrationUsernameRace +--- PASS: TestIntegrationUsernameRace (0.05s) +PASS +ok messenger/internal/store 0.058s diff --git a/evidence/host.txt b/evidence/host.txt new file mode 100644 index 00000000..1951fb95 --- /dev/null +++ b/evidence/host.txt @@ -0,0 +1,8 @@ +uname=Linux 7.0.0-31-generic x86_64 +nproc=8 +mem_kib=7381312 +go=go version go1.26.0 linux/amd64 +CONTAINER REPOSITORY TAG PLATFORM IMAGE ID SIZE CREATED +messenger-lab2-api-1 messenger-lab2-api latest linux/amd64 53d3e79b608f 5.48MB 14 seconds ago +messenger-lab2-postgres-1 postgres 16.10-bookworm linux/amd64 38471f330eb8 155MB 5 minutes ago +messenger-lab2-redis-1 redis 7.4.6-alpine linux/amd64 3b73847e7287 17.3MB 6 minutes ago diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..e0e09504 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,12 @@ +=== started_at before === +/messenger-lab2-api-1 2026-10-30T07:05:53.345595506Z +/messenger-lab2-postgres-1 2026-10-30T07:05:47.55799061Z +/messenger-lab2-redis-1 2026-10-30T07:05:47.557221089Z +test -n "scripts/restart.sh" +python3 tests/resilience.py --base-url "http://localhost:8080" --mode persistence --action-script "scripts/restart.sh" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +=== started_at after === +/messenger-lab2-api-1 2026-10-30T07:06:30.591040874Z +/messenger-lab2-postgres-1 2026-10-30T07:06:30.255241089Z +/messenger-lab2-redis-1 2026-10-30T07:06:30.310922939Z diff --git a/evidence/redis_persistence.txt b/evidence/redis_persistence.txt new file mode 100644 index 00000000..4409f85d --- /dev/null +++ b/evidence/redis_persistence.txt @@ -0,0 +1,4 @@ +rdb_last_bgsave_status:ok +aof_enabled:1 +aof_last_bgrewrite_status:ok +aof_last_write_status:ok diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..404a2c60 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/track2_after.txt b/evidence/track2_after.txt new file mode 100644 index 00000000..8cdcb7cd --- /dev/null +++ b/evidence/track2_after.txt @@ -0,0 +1,7 @@ +big-1|big-1 +big-80000|big-80000 +chats|104 +messages|100000 +mid-15000|mid-15000 +tiny-sample|tiny-100 +users|1 diff --git a/evidence/track2_before.txt b/evidence/track2_before.txt new file mode 100644 index 00000000..8cdcb7cd --- /dev/null +++ b/evidence/track2_before.txt @@ -0,0 +1,7 @@ +big-1|big-1 +big-80000|big-80000 +chats|104 +messages|100000 +mid-15000|mid-15000 +tiny-sample|tiny-100 +users|1 diff --git a/evidence/track2_cursor.txt b/evidence/track2_cursor.txt new file mode 100644 index 00000000..111bc0e0 --- /dev/null +++ b/evidence/track2_cursor.txt @@ -0,0 +1 @@ +2026-01-01 00:00:00.050001|c471f25a-9805-4beb-9a46-c9564042507c diff --git a/evidence/track2_explain.txt b/evidence/track2_explain.txt new file mode 100644 index 00000000..567d54e4 --- /dev/null +++ b/evidence/track2_explain.txt @@ -0,0 +1,144 @@ +=== recreate bench === +CREATE TABLE +CREATE TABLE +CREATE INDEX +CREATE TABLE +CREATE INDEX +CREATE TABLE +CREATE INDEX +=== seed uneven 100000 messages === +INSERT 0 1 +INSERT 0 4 +INSERT 0 4 +INSERT 0 100 +INSERT 0 100 +INSERT 0 100000 + title | messages +----------+---------- + big | 80000 + mid | 15000 + small | 4000 + tiny-1 | 10 + tiny-10 | 10 + tiny-100 | 10 + tiny-11 | 10 + tiny-12 | 10 +(8 rows) + + messages_total +---------------- + 100000 +(1 row) + + synchronous_commit +-------------------- + on +(1 row) + +=== cursor in the big chat === +=== no secondary index: seq scan of the whole table === +DROP INDEX +=== EXPLAIN seq_scan chat=bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1 === +ANALYZE + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=4100.97..4106.72 rows=50 width=56) (actual time=11.330..13.785 rows=50 loops=1) + Buffers: shared hit=1248 + -> Gather Merge (cost=4100.97..6800.71 rows=23476 width=56) (actual time=11.329..13.780 rows=50 loops=1) + Workers Planned: 1 + Workers Launched: 1 + Buffers: shared hit=1248 + -> Sort (cost=3100.96..3159.65 rows=23476 width=56) (actual time=9.597..9.599 rows=34 loops=2) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 28kB + Buffers: shared hit=1248 + Worker 0: Sort Method: top-N heapsort Memory: 28kB + -> Parallel Seq Scan on messages (cost=0.00..2321.10 rows=23476 width=56) (actual time=2.023..6.650 rows=20000 loops=2) + Filter: ((chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.050001+00'::timestamp with time zone, 'c471f25a-9805-4beb-9a46-c9564042507c'::uuid))) + Rows Removed by Filter: 30000 + Buffers: shared hit=1233 + Planning: + Buffers: shared hit=32 + Planning Time: 0.152 ms + Execution Time: 13.824 ms +(19 rows) + +=== index on (created_at, id) only === +CREATE INDEX +=== EXPLAIN time_only_big chat=bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1 === +ANALYZE + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..7.84 rows=50 width=56) (actual time=0.020..0.038 rows=50 loops=1) + Buffers: shared hit=2 read=3 + -> Index Scan using messages_time_idx on messages (cost=0.42..5946.46 rows=40067 width=56) (actual time=0.018..0.033 rows=50 loops=1) + Index Cond: (ROW(created_at, id) > ROW('2026-01-01 00:00:00.050001+00'::timestamp with time zone, 'c471f25a-9805-4beb-9a46-c9564042507c'::uuid)) + Filter: (chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1'::uuid) + Buffers: shared hit=2 read=3 + Planning: + Buffers: shared hit=30 read=1 + Planning Time: 0.166 ms + Execution Time: 0.066 ms +(10 rows) + +=== EXPLAIN time_only_small chat=bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb3 === +ANALYZE + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..146.66 rows=50 width=56) (actual time=0.045..0.252 rows=50 loops=1) + Buffers: shared hit=57 read=6 + -> Index Scan using messages_time_idx on messages (cost=0.42..5888.31 rows=2013 width=56) (actual time=0.043..0.247 rows=50 loops=1) + Index Cond: (ROW(created_at, id) > ROW('2026-01-01 00:00:00.050001+00'::timestamp with time zone, 'c471f25a-9805-4beb-9a46-c9564042507c'::uuid)) + Filter: (chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb3'::uuid) + Rows Removed by Filter: 1245 + Buffers: shared hit=57 read=6 + Planning: + Buffers: shared hit=29 + Planning Time: 0.223 ms + Execution Time: 0.297 ms +(11 rows) + +=== insert cost with time index === +NOTICE: insert_5000_time_index_ms 109.111 +DO +DELETE 5000 +DROP INDEX +CREATE INDEX +=== EXPLAIN history_big chat=bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1 === +ANALYZE + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..9.42 rows=50 width=56) (actual time=0.030..0.049 rows=50 loops=1) + Buffers: shared hit=2 read=3 + -> Index Scan using messages_history_idx on messages (cost=0.42..7225.92 rows=40147 width=56) (actual time=0.029..0.044 rows=50 loops=1) + Index Cond: ((chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.050001+00'::timestamp with time zone, 'c471f25a-9805-4beb-9a46-c9564042507c'::uuid))) + Buffers: shared hit=2 read=3 + Planning: + Buffers: shared hit=32 read=1 + Planning Time: 0.387 ms + Execution Time: 0.089 ms +(9 rows) + +=== EXPLAIN history_small chat=bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb3 === +ANALYZE + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..116.76 rows=50 width=56) (actual time=0.022..0.047 rows=50 loops=1) + Buffers: shared hit=3 read=2 + -> Index Scan using messages_history_idx on messages (cost=0.42..4549.26 rows=1955 width=56) (actual time=0.021..0.042 rows=50 loops=1) + Index Cond: ((chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb3'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.050001+00'::timestamp with time zone, 'c471f25a-9805-4beb-9a46-c9564042507c'::uuid))) + Buffers: shared hit=3 read=2 + Planning: + Buffers: shared hit=27 + Planning Time: 0.144 ms + Execution Time: 0.073 ms +(9 rows) + +=== insert cost with history index === +NOTICE: insert_5000_history_index_ms 100.134 +DO +DELETE 5000 +=== snapshot before dump === +=== dump and restore === +CREATE DATABASE +PASS track2 diff --git a/evidence/track2_summary.txt b/evidence/track2_summary.txt new file mode 100644 index 00000000..849b3d06 --- /dev/null +++ b/evidence/track2_summary.txt @@ -0,0 +1,6 @@ +messages_before=messages|100000 +dump_ms=585 +restore_ms=646 +compare=match +synchronous_commit=on +hypothesis=history index reads one chat range; time-only index filters chat_id after walking created_at diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..6844cdfb --- /dev/null +++ b/go.mod @@ -0,0 +1,20 @@ +module messenger + +go 1.26.0 + +require ( + github.com/jackc/pgx/v5 v5.11.0 + github.com/redis/go-redis/v9 v9.23.0 + golang.org/x/crypto v0.58.0 +) + +require ( + github.com/cespare/xxhash/v2 v2.3.0 // 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 + go.uber.org/atomic v1.12.0 // indirect + golang.org/x/sync v0.24.0 // indirect + golang.org/x/sys v0.49.0 // indirect + golang.org/x/text v0.43.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..e82c5df0 --- /dev/null +++ b/go.sum @@ -0,0 +1,41 @@ +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.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +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.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +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/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw= +github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s= +github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0= +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.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE= +github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg= +github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= +github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= +go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE= +go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk= +go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= +go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= +golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54= +golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w= +golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= +golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA= +golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc= +golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s= +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= diff --git a/internal/api/auth.go b/internal/api/auth.go new file mode 100644 index 00000000..9b635bf8 --- /dev/null +++ b/internal/api/auth.go @@ -0,0 +1,182 @@ +package api + +import ( + "crypto/rand" + "encoding/base64" + "encoding/hex" + "errors" + "io" + "net/http" + "strings" + "time" + "unicode/utf8" + + "messenger/internal/password" + "messenger/internal/session" + "messenger/internal/store" +) + +const ( + basicChallenge = `Basic realm="messenger", charset="UTF-8"` + bearerChallenge = `Bearer realm="messenger"` +) + +func (a *API) createSession(w http.ResponseWriter, r *http.Request) { + if !emptyBody(r) { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "У входа не должно быть тела", 0) + return + } + username, plain, ok := parseBasic(r) + if !ok || !usernameRe.MatchString(username) || !validPassword(plain) { + a.unauthorized(w, r, basicChallenge) + return + } + user, hash, err := a.store.UserByUsername(r.Context(), username) + if errors.Is(err, store.ErrNotFound) { + password.Verify(plain, a.dummyHash) + a.unauthorized(w, r, basicChallenge) + return + } + if a.writeStoreErr(w, r, err) { + return + } + if !password.Verify(plain, hash) { + a.unauthorized(w, r, basicChallenge) + return + } + token, err := newToken() + if err != nil { + a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0) + return + } + expires := time.Now().UTC().Add(a.sessionTTL).Truncate(time.Microsecond) + if err := a.sessions.Create(r.Context(), token, user.ID, expires); a.writeStoreErr(w, r, err) { + return + } + writeJSON(w, http.StatusCreated, map[string]any{ + "token": token, + "token_type": "Bearer", + "expires_at": formatTime(expires), + "user": asUser(user), + }) +} + +func (a *API) revokeSession(w http.ResponseWriter, r *http.Request) { + token, ok := a.bearerToken(w, r) + if !ok { + return + } + if _, _, err := a.sessions.Lookup(r.Context(), token); err != nil { + if errors.Is(err, session.ErrNotFound) { + a.unauthorized(w, r, bearerChallenge) + return + } + a.writeStoreErr(w, r, err) + return + } + if err := a.sessions.Revoke(r.Context(), token); err != nil { + if errors.Is(err, session.ErrNotFound) { + a.unauthorized(w, r, bearerChallenge) + return + } + a.writeStoreErr(w, r, err) + return + } + w.WriteHeader(http.StatusNoContent) +} + +func (a *API) authenticate(w http.ResponseWriter, r *http.Request) (store.User, bool) { + token, ok := a.bearerToken(w, r) + if !ok { + return store.User{}, false + } + userID, expires, err := a.sessions.Lookup(r.Context(), token) + if errors.Is(err, session.ErrNotFound) || (err == nil && !time.Now().Before(expires)) { + if err == nil { + _ = a.sessions.Revoke(r.Context(), token) + } + a.unauthorized(w, r, bearerChallenge) + return store.User{}, false + } + if err != nil { + a.writeStoreErr(w, r, err) + return store.User{}, false + } + user, err := a.store.User(r.Context(), userID) + if errors.Is(err, store.ErrNotFound) { + a.unauthorized(w, r, bearerChallenge) + return store.User{}, false + } + if a.writeStoreErr(w, r, err) { + return store.User{}, false + } + return user, true +} + +func (a *API) bearerToken(w http.ResponseWriter, r *http.Request) (string, bool) { + scheme, param, ok := splitAuth(r.Header.Get("Authorization")) + if !ok || !strings.EqualFold(scheme, "Bearer") || param == "" || len(param) > 512 || strings.Contains(param, " ") { + a.unauthorized(w, r, bearerChallenge) + return "", false + } + return param, true +} + +func (a *API) unauthorized(w http.ResponseWriter, r *http.Request, challenge string) { + w.Header().Set("WWW-Authenticate", challenge) + a.fail(w, r, http.StatusUnauthorized, "unauthorized", "Нет действительной идентификации", 0) +} + +func parseBasic(r *http.Request) (string, string, bool) { + scheme, param, ok := splitAuth(r.Header.Get("Authorization")) + if !ok || !strings.EqualFold(scheme, "Basic") || param == "" { + return "", "", false + } + raw, err := base64.StdEncoding.DecodeString(param) + if err != nil { + raw, err = base64.RawStdEncoding.DecodeString(param) + if err != nil { + return "", "", false + } + } + if !utf8.Valid(raw) { + return "", "", false + } + username, plain, ok := strings.Cut(string(raw), ":") + if !ok || username == "" { + return "", "", false + } + return username, plain, true +} + +func splitAuth(header string) (string, string, bool) { + scheme, param, ok := strings.Cut(strings.TrimSpace(header), " ") + if !ok { + return "", "", false + } + param = strings.TrimSpace(param) + if scheme == "" || param == "" { + return "", "", false + } + return scheme, param, true +} + +func emptyBody(r *http.Request) bool { + if r.Body == nil || r.ContentLength == 0 { + return true + } + buf := make([]byte, 1) + n, err := r.Body.Read(buf) + if n > 0 { + return false + } + return err == io.EOF || err == nil +} + +func newToken() (string, error) { + var b [32]byte + if _, err := rand.Read(b[:]); err != nil { + return "", err + } + return hex.EncodeToString(b[:]), nil +} diff --git a/internal/api/handlers.go b/internal/api/handlers.go new file mode 100644 index 00000000..28966f7c --- /dev/null +++ b/internal/api/handlers.go @@ -0,0 +1,323 @@ +package api + +import ( + "context" + "errors" + "net/http" + "strings" + "time" + + "messenger/internal/session" + "messenger/internal/store" +) + +func (a *API) live(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +func (a *API) ready(w http.ResponseWriter, r *http.Request) { + if a.shutting.Load() { + a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервер останавливается", 1) + return + } + ctx, cancel := context.WithTimeout(r.Context(), 800*time.Millisecond) + defer cancel() + if err := a.store.Ping(ctx); err != nil || a.sessions.Ping(ctx) != nil { + a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1) + return + } + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +func (a *API) route(w http.ResponseWriter, r *http.Request) { + path := r.URL.Path + switch { + case path == "/api/v1/users" && r.Method == http.MethodPost: + a.createUser(w, r) + case path == "/api/v1/users/me" && r.Method == http.MethodGet: + a.currentUser(w, r) + case path == "/api/v1/auth/sessions" && r.Method == http.MethodPost: + a.createSession(w, r) + case path == "/api/v1/auth/sessions/current" && r.Method == http.MethodDelete: + a.revokeSession(w, r) + case path == "/api/v1/chats" && r.Method == http.MethodPost: + a.createChat(w, r) + case path == "/api/v1/chats" && r.Method == http.MethodGet: + a.listChats(w, r) + default: + chatID, messages, ok := splitChatPath(path) + if !ok { + if knownWrongMethod(path) { + a.fail(w, r, http.StatusMethodNotAllowed, "invalid_request", "Метод не поддерживается", 0) + return + } + a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0) + return + } + switch { + case !messages && r.Method == http.MethodGet: + a.getChat(w, r, chatID) + case messages && r.Method == http.MethodPost: + a.createMessage(w, r, chatID) + case messages && r.Method == http.MethodGet: + a.listMessages(w, r, chatID) + default: + a.fail(w, r, http.StatusMethodNotAllowed, "invalid_request", "Метод не поддерживается", 0) + } + } +} + +func knownWrongMethod(path string) bool { + switch path { + case "/api/v1/users", "/api/v1/users/me", "/api/v1/chats", + "/api/v1/auth/sessions", "/api/v1/auth/sessions/current": + return true + default: + return false + } +} + +func (a *API) createUser(w http.ResponseWriter, r *http.Request) { + var body struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + } + if !a.readJSON(w, r, &body) { + return + } + if !usernameRe.MatchString(body.Username) || !validText(body.DisplayName, 1, 100) || !validPassword(body.Password) { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректные поля пользователя", 0) + return + } + hash, err := a.hasher.Hash(body.Password) + if err != nil { + a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0) + return + } + user, err := a.store.CreateUser(r.Context(), body.Username, body.DisplayName, hash) + if a.writeStoreErr(w, r, err) { + return + } + writeJSON(w, http.StatusCreated, asUser(user)) +} + +func (a *API) currentUser(w http.ResponseWriter, r *http.Request) { + user, ok := a.authenticate(w, r) + if !ok { + return + } + writeJSON(w, http.StatusOK, asUser(user)) +} + +func (a *API) createChat(w http.ResponseWriter, r *http.Request) { + caller, ok := a.authenticate(w, r) + if !ok { + return + } + var body struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + } + if !a.readJSON(w, r, &body) { + return + } + if !validText(body.Title, 1, 100) || len(body.MemberIDs) < 1 || len(body.MemberIDs) > 100 { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректные поля чата", 0) + return + } + ids := make([]string, len(body.MemberIDs)) + seen := make(map[string]struct{}, len(body.MemberIDs)) + callerIn := false + for i, raw := range body.MemberIDs { + id, ok := canonicalUUID(raw) + if !ok { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0) + return + } + if _, dup := seen[id]; dup { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0) + return + } + seen[id] = struct{}{} + _, err := a.store.User(r.Context(), id) + if errors.Is(err, store.ErrNotFound) { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0) + return + } + if a.writeStoreErr(w, r, err) { + return + } + if id == caller.ID { + callerIn = true + } + ids[i] = id + } + if !callerIn { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0) + return + } + chat, err := a.store.CreateChat(r.Context(), body.Title, ids, caller.ID) + if errors.Is(err, store.ErrInvalid) { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный список участников", 0) + return + } + if a.writeStoreErr(w, r, err) { + return + } + writeJSON(w, http.StatusCreated, asChat(chat)) +} + +func (a *API) listChats(w http.ResponseWriter, r *http.Request) { + user, ok := a.authenticate(w, r) + if !ok { + return + } + limit, cur, ok := a.pageQuery(w, r, "chats:"+user.ID) + if !ok { + return + } + items, hasMore, err := a.store.ListChats(r.Context(), user.ID, cur, limit) + if a.writeStoreErr(w, r, err) { + return + } + out := make([]chatJSON, 0, len(items)) + for _, c := range items { + out = append(out, asChat(c)) + } + var next *string + if hasMore && len(items) > 0 { + last := items[len(items)-1] + encoded := encodeCursor(cursorPayload{Scope: "chats:" + user.ID, ID: last.ID, At: formatTime(last.CreatedAt)}) + next = &encoded + } + writeJSON(w, http.StatusOK, chatPage{Items: out, NextCursor: next}) +} + +func (a *API) getChat(w http.ResponseWriter, r *http.Request, rawID string) { + user, ok := a.authenticate(w, r) + if !ok { + return + } + id, ok := a.chatID(w, r, rawID) + if !ok { + return + } + chat, err := a.store.ChatFor(r.Context(), id, user.ID) + if a.writeStoreErr(w, r, err) { + return + } + writeJSON(w, http.StatusOK, asChat(chat)) +} + +func (a *API) createMessage(w http.ResponseWriter, r *http.Request, rawID string) { + user, ok := a.authenticate(w, r) + if !ok { + return + } + id, ok := a.chatID(w, r, rawID) + if !ok { + return + } + if _, err := a.store.ChatFor(r.Context(), id, user.ID); a.writeStoreErr(w, r, err) { + return + } + var body struct { + Text string `json:"text"` + } + if !a.readJSON(w, r, &body) { + return + } + if !validText(body.Text, 1, 4000) { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный текст сообщения", 0) + return + } + msg, err := a.store.AddMessage(r.Context(), id, user.ID, body.Text) + if a.writeStoreErr(w, r, err) { + return + } + writeJSON(w, http.StatusCreated, asMessage(msg)) +} + +func (a *API) listMessages(w http.ResponseWriter, r *http.Request, rawID string) { + user, ok := a.authenticate(w, r) + if !ok { + return + } + id, ok := a.chatID(w, r, rawID) + if !ok { + return + } + if _, err := a.store.ChatFor(r.Context(), id, user.ID); a.writeStoreErr(w, r, err) { + return + } + limit, cur, ok := a.pageQuery(w, r, "msg:"+id) + if !ok { + return + } + items, hasMore, err := a.store.ListMessages(r.Context(), id, user.ID, cur, limit) + if a.writeStoreErr(w, r, err) { + return + } + out := make([]messageJSON, 0, len(items)) + for _, m := range items { + out = append(out, asMessage(m)) + } + var next *string + if hasMore && len(items) > 0 { + last := items[len(items)-1] + encoded := encodeCursor(cursorPayload{Scope: "msg:" + id, ID: last.ID, At: formatTime(last.CreatedAt)}) + next = &encoded + } + writeJSON(w, http.StatusOK, messagePage{Items: out, NextCursor: next}) +} + +func (a *API) chatID(w http.ResponseWriter, r *http.Request, raw string) (string, bool) { + id, ok := canonicalUUID(raw) + if !ok { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный идентификатор", 0) + return "", false + } + return id, true +} + +func (a *API) writeStoreErr(w http.ResponseWriter, r *http.Request, err error) bool { + if err == nil { + return false + } + switch { + case errors.Is(err, store.ErrUnavailable), errors.Is(err, session.ErrUnavailable): + a.fail(w, r, http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен", 1) + case errors.Is(err, store.ErrConflict): + a.fail(w, r, http.StatusConflict, "conflict", "Имя пользователя уже занято", 0) + case errors.Is(err, store.ErrNotFound): + a.fail(w, r, http.StatusNotFound, "not_found", "Объект не найден", 0) + case errors.Is(err, store.ErrInvalid): + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректные данные", 0) + case errors.Is(err, store.ErrBadCursor): + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0) + default: + a.log.Error("store", "request_id", requestIDFrom(r)) + a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0) + } + return true +} + +func splitChatPath(path string) (id string, messages bool, ok bool) { + const prefix = "/api/v1/chats/" + if !strings.HasPrefix(path, prefix) { + return "", false, false + } + rest := strings.TrimPrefix(path, prefix) + if rest == "" || strings.Contains(rest, "/") && !strings.HasSuffix(rest, "/messages") { + return "", false, false + } + if strings.HasSuffix(rest, "/messages") { + id = strings.TrimSuffix(rest, "/messages") + if id == "" || strings.Contains(id, "/") { + return "", false, false + } + return id, true, true + } + return rest, false, true +} diff --git a/internal/api/http.go b/internal/api/http.go new file mode 100644 index 00000000..ac688c49 --- /dev/null +++ b/internal/api/http.go @@ -0,0 +1,314 @@ +package api + +import ( + "bytes" + "crypto/rand" + "encoding/base64" + "encoding/hex" + "encoding/json" + "io" + "net/http" + "reflect" + "regexp" + "strconv" + "strings" + "time" + "unicode/utf8" + + "messenger/internal/store" +) + +var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) +var uuidRe = regexp.MustCompile(`(?i)^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$`) +var limitRe = regexp.MustCompile(`^[0-9]{1,3}$`) +var requestIDRe = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,64}$`) + +type errorEnvelope struct { + Error errorObject `json:"error"` +} + +type errorObject struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} + +type userJSON struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt string `json:"created_at"` +} + +type chatJSON struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` +} + +type messageJSON 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 chatPage struct { + Items []chatJSON `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +type messagePage struct { + Items []messageJSON `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +type cursorPayload struct { + Scope string `json:"scope"` + ID string `json:"id"` + At string `json:"at"` +} + +type statusWriter struct { + http.ResponseWriter + status int + wrote bool +} + +func (s *statusWriter) WriteHeader(code int) { + if s.wrote { + return + } + s.status = code + s.wrote = true + s.ResponseWriter.WriteHeader(code) +} + +func (s *statusWriter) Write(b []byte) (int, error) { + if !s.wrote { + s.WriteHeader(http.StatusOK) + } + return s.ResponseWriter.Write(b) +} + +func (a *API) fail(w http.ResponseWriter, r *http.Request, status int, code, message string, retryAfter int) { + if retryAfter > 0 { + w.Header().Set("Retry-After", strconv.Itoa(retryAfter)) + } + writeJSON(w, status, errorEnvelope{Error: errorObject{ + Code: code, + Message: message, + RequestID: requestIDFrom(r), + }}) +} + +func writeJSON(w http.ResponseWriter, status int, v any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + enc := json.NewEncoder(w) + enc.SetEscapeHTML(false) + _ = enc.Encode(v) +} + +func (a *API) readJSON(w http.ResponseWriter, r *http.Request, dst any) bool { + media := "" + if ct := r.Header.Get("Content-Type"); ct != "" { + media = strings.TrimSpace(strings.Split(ct, ";")[0]) + } + if !strings.EqualFold(media, "application/json") { + a.fail(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "Нужен Content-Type application/json", 0) + return false + } + body, err := io.ReadAll(r.Body) + if err != nil || !utf8.Valid(body) || !decodeExactJSON(body, dst) { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный JSON", 0) + return false + } + return true +} + +// decodeExactJSON принимает один JSON-объект: точные имена полей, без хвоста и без замены битого UTF-8. +func decodeExactJSON(body []byte, dst any) bool { + dec := json.NewDecoder(bytes.NewReader(body)) + var fields map[string]json.RawMessage + if err := dec.Decode(&fields); err != nil || fields == nil { + return false + } + var trailing json.RawMessage + if err := dec.Decode(&trailing); err != io.EOF { + return false + } + allowed, ok := jsonFieldNames(dst) + if !ok { + return false + } + for name := range fields { + if _, ok := allowed[name]; !ok { + return false + } + } + return json.Unmarshal(body, dst) == nil +} + +func jsonFieldNames(dst any) (map[string]struct{}, bool) { + t := reflect.TypeOf(dst) + if t == nil || t.Kind() != reflect.Pointer { + return nil, false + } + t = t.Elem() + if t.Kind() != reflect.Struct { + return nil, false + } + names := make(map[string]struct{}, t.NumField()) + for i := 0; i < t.NumField(); i++ { + name, _, _ := strings.Cut(t.Field(i).Tag.Get("json"), ",") + if name == "" || name == "-" { + return nil, false + } + names[name] = struct{}{} + } + return names, true +} + +func validPassword(s string) bool { + if !utf8.ValidString(s) { + return false + } + n := utf8.RuneCountInString(s) + return n >= 12 && n <= 128 && strings.TrimSpace(s) != "" +} + +func (a *API) pageQuery(w http.ResponseWriter, r *http.Request, scope string) (int, *store.Cursor, bool) { + q := r.URL.Query() + limit := 50 + if q.Has("limit") { + raw := q.Get("limit") + n, err := strconv.Atoi(raw) + if err != nil || !limitRe.MatchString(raw) || n < 1 || n > 100 { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный limit", 0) + return 0, nil, false + } + limit = n + } + if !q.Has("cursor") { + return limit, nil, true + } + raw := q.Get("cursor") + if raw == "" || len(raw) > 512 { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0) + return 0, nil, false + } + payload, err := decodeCursor(raw) + if err != nil || payload.Scope != scope || payload.ID == "" || payload.At == "" { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0) + return 0, nil, false + } + at, err := time.Parse("2006-01-02T15:04:05.000000Z", payload.At) + if err != nil { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0) + return 0, nil, false + } + id, ok := canonicalUUID(payload.ID) + if !ok { + a.fail(w, r, http.StatusBadRequest, "invalid_request", "Некорректный cursor", 0) + return 0, nil, false + } + return limit, &store.Cursor{ID: id, At: at}, true +} + +func asUser(u store.User) userJSON { + return userJSON{ + ID: u.ID, + Username: u.Username, + DisplayName: u.DisplayName, + CreatedAt: formatTime(u.CreatedAt), + } +} + +func asChat(c store.Chat) chatJSON { + ids := c.MemberIDs + if ids == nil { + ids = []string{} + } + return chatJSON{ + ID: c.ID, + Title: c.Title, + MemberIDs: ids, + CreatedAt: formatTime(c.CreatedAt), + } +} + +func asMessage(m store.Message) messageJSON { + return messageJSON{ + ID: m.ID, + ChatID: m.ChatID, + SenderID: m.SenderID, + Text: m.Text, + CreatedAt: formatTime(m.CreatedAt), + } +} + +func formatTime(t time.Time) string { + return t.UTC().Format("2006-01-02T15:04:05.000000Z") +} + +func canonicalUUID(s string) (string, bool) { + if !uuidRe.MatchString(s) { + return "", false + } + return strings.ToLower(s), true +} + +func validText(s string, min, max int) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= min && n <= max +} + +func requestID(r *http.Request) string { + incoming := strings.TrimSpace(r.Header.Get("X-Request-Id")) + if requestIDRe.MatchString(incoming) { + return incoming + } + var b [16]byte + if _, err := rand.Read(b[:]); err != nil { + return strconv.FormatInt(time.Now().UnixNano(), 36) + } + return hex.EncodeToString(b[:]) +} + +func encodeCursor(p cursorPayload) string { + raw, err := json.Marshal(p) + if err != nil { + return "" + } + return base64.RawURLEncoding.EncodeToString(raw) +} + +func decodeCursor(s string) (cursorPayload, error) { + b, err := base64.RawURLEncoding.DecodeString(s) + if err != nil { + b, err = base64.URLEncoding.DecodeString(s) + if err != nil { + return cursorPayload{}, err + } + } + dec := json.NewDecoder(bytes.NewReader(b)) + dec.DisallowUnknownFields() + var p cursorPayload + if err := dec.Decode(&p); err != nil { + return cursorPayload{}, err + } + var trailing json.RawMessage + if err := dec.Decode(&trailing); err != io.EOF { + if err == nil { + err = io.ErrUnexpectedEOF + } + return cursorPayload{}, err + } + return p, nil +} diff --git a/internal/api/server.go b/internal/api/server.go new file mode 100644 index 00000000..f43570f3 --- /dev/null +++ b/internal/api/server.go @@ -0,0 +1,105 @@ +package api + +import ( + "context" + "log/slog" + "net/http" + "sync/atomic" + "time" + + "messenger/internal/password" + "messenger/internal/session" + "messenger/internal/store" +) + +type ctxKey struct{} + +type API struct { + store store.Repository + sessions session.Store + hasher password.Params + dummyHash string + sessionTTL time.Duration + log *slog.Logger + shutting atomic.Bool +} + +// New связывает HTTP с хранилищем и сессиями. +// dummyHash нужен, чтобы несуществующий username тратил столько же KDF, сколько существующий. +func New(st store.Repository, sessions session.Store, hasher password.Params, sessionTTL time.Duration, log *slog.Logger) *API { + if log == nil { + log = slog.Default() + } + if sessionTTL <= 0 { + sessionTTL = time.Hour + } + dummy, err := hasher.Hash("dummy-password-not-a-login") + if err != nil { + // Параметры KDF проверяются на старте. Пустая строка заставит Verify сразу вернуть false. + dummy = "" + } + return &API{ + store: st, + sessions: sessions, + hasher: hasher, + dummyHash: dummy, + sessionTTL: sessionTTL, + log: log, + } +} + +// BeginShutdown переводит /health/ready в 503 и говорит новым бизнес-запросам +// отказать до закрытия слушателя. Уже принятые обработчики дорабатывают. +func (a *API) BeginShutdown() { + a.shutting.Store(true) + a.log.Info("shutdown started") +} + +// Точка входа +func (a *API) ServeHTTP(w http.ResponseWriter, r *http.Request) { + sw := &statusWriter{ResponseWriter: w, status: http.StatusOK} + start := time.Now() + id := requestID(r) + sw.Header().Set("X-Request-Id", id) + r = r.WithContext(context.WithValue(r.Context(), ctxKey{}, id)) + + defer func() { + if p := recover(); p != nil { + a.log.Error("panic", "request_id", id) + if !sw.wrote { + a.fail(sw, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0) + } + } + a.log.Info("request", + "request_id", id, + "method", r.Method, + "path", r.URL.Path, + "status", sw.status, + "duration_ms", time.Since(start).Milliseconds(), + "bytes_in", r.ContentLength, + ) + }() + + switch { + case r.Method == http.MethodGet && r.URL.Path == "/health/live": + a.live(sw, r) + return + case r.Method == http.MethodGet && r.URL.Path == "/health/ready": + a.ready(sw, r) + return + } + + if a.shutting.Load() { + a.fail(sw, r, http.StatusServiceUnavailable, "unavailable", "Сервер останавливается", 1) + return + } + a.route(sw, r) +} + +func requestIDFrom(r *http.Request) string { + id, _ := r.Context().Value(ctxKey{}).(string) + if id == "" { + return "unknown" + } + return id +} diff --git a/internal/api/server_test.go b/internal/api/server_test.go new file mode 100644 index 00000000..5c76e91b --- /dev/null +++ b/internal/api/server_test.go @@ -0,0 +1,614 @@ +package api + +import ( + "bytes" + "context" + "encoding/base64" + "encoding/json" + "io" + "log/slog" + "net/http" + "net/http/httptest" + "net/url" + "strings" + "sync" + "testing" + "time" + + "messenger/internal/password" + "messenger/internal/session" + "messenger/internal/store" +) + +const testPassword = "correct-horse-1" + +type labServer struct { + URL string + tokens map[string]string + api *API + store store.Repository + sess session.Store +} + +func newServer(t *testing.T) *labServer { + return newServerTTL(t, time.Hour) +} + +func newServerTTL(t *testing.T, ttl time.Duration) *labServer { + t.Helper() + st := store.New() + sess := session.NewMemory() + application := New(st, sess, password.Params{Time: 1, Memory: 8, Threads: 1}, ttl, slog.New(slog.NewJSONHandler(io.Discard, nil))) + srv := httptest.NewServer(application) + t.Cleanup(srv.Close) + return &labServer{URL: srv.URL, tokens: map[string]string{}, api: application, store: st, sess: sess} +} + +func (e *labServer) bearer(user string) string { + if user == "" { + return "" + } + if tok, ok := e.tokens[user]; ok { + return tok + } + return "unknown-session-token" +} + +func do(t *testing.T, env *labServer, method, url, user string, body any, raw []byte, contentType string) (int, http.Header, []byte) { + t.Helper() + var rdr io.Reader + if raw != nil { + rdr = bytes.NewReader(raw) + } else if body != nil { + b, err := json.Marshal(body) + if err != nil { + t.Fatal(err) + } + rdr = bytes.NewReader(b) + } + req, err := http.NewRequest(method, url, rdr) + if err != nil { + t.Fatal(err) + } + if body != nil || raw != nil { + if contentType == "" { + contentType = "application/json" + } + req.Header.Set("Content-Type", contentType) + } + if tok := env.bearer(user); tok != "" { + req.Header.Set("Authorization", "Bearer "+tok) + } + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + data, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatal(err) + } + if resp.Header.Get("X-Request-Id") == "" { + t.Fatalf("%s %s: missing X-Request-Id", method, url) + } + if resp.StatusCode >= 400 { + var env errorEnvelope + if err := json.Unmarshal(data, &env); err != nil { + t.Fatalf("error json: %v body %s", err, data) + } + if env.Error.RequestID != resp.Header.Get("X-Request-Id") || env.Error.Code == "" || env.Error.Message == "" { + t.Fatalf("bad error envelope: %+v", env) + } + } + return resp.StatusCode, resp.Header, data +} + +func createUser(t *testing.T, env *labServer, username, display string) userJSON { + t.Helper() + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", map[string]string{ + "username": username, "display_name": display, "password": testPassword, + }, nil, "") + if status != http.StatusCreated { + t.Fatalf("create user %s: %d %s", username, status, body) + } + if bytes.Contains(body, []byte("password")) || bytes.Contains(body, []byte("argon2")) { + t.Fatalf("user response leaked a secret: %s", body) + } + var u userJSON + if err := json.Unmarshal(body, &u); err != nil { + t.Fatal(err) + } + req, err := http.NewRequest(http.MethodPost, env.URL+"/api/v1/auth/sessions", nil) + if err != nil { + t.Fatal(err) + } + req.SetBasicAuth(username, testPassword) + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + defer resp.Body.Close() + raw, _ := io.ReadAll(resp.Body) + if resp.StatusCode != http.StatusCreated { + t.Fatalf("login %s: %d %s", username, resp.StatusCode, raw) + } + var sess struct { + Token string `json:"token"` + } + if err := json.Unmarshal(raw, &sess); err != nil || len(sess.Token) < 32 { + t.Fatalf("session: %s", raw) + } + env.tokens[u.ID] = sess.Token + return u +} + +func createChat(t *testing.T, env *labServer, caller, title string, members ...string) chatJSON { + t.Helper() + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats", caller, map[string]any{ + "title": title, "member_ids": members, + }, nil, "") + if status != http.StatusCreated { + t.Fatalf("create chat: %d %s", status, body) + } + var c chatJSON + if err := json.Unmarshal(body, &c); err != nil { + t.Fatal(err) + } + return c +} + +func TestInvalidJSONExtraFieldAndTypes(t *testing.T) { + env := newServer(t) + cases := [][]byte{ + []byte(`{`), + []byte(`{"username":"abc","display_name":"Алиса","extra":1}`), + []byte(`{"username":1,"display_name":"Алиса"}`), + []byte(`null`), + } + for _, raw := range cases { + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", nil, raw, "application/json") + if status != http.StatusBadRequest || !bytes.Contains(body, []byte(`"invalid_request"`)) { + t.Fatalf("body %s: %d %s", raw, status, body) + } + } + status, _, _ := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", nil, []byte(`{"username":"abc","display_name":"Алиса"}`), "text/plain") + if status != http.StatusUnsupportedMediaType { + t.Fatalf("content type: %d", status) + } +} + +func TestStrictJSONNamesUTF8AndCursorTail(t *testing.T) { + env := newServer(t) + bad := [][]byte{ + []byte(`{"username":"bad_json","display_name":"Я"}]`), + []byte(`{"username":"bad_json","display_name":"Я"}}`), + []byte(`{"Username":"bad_case","display_name":"Я"}`), + append([]byte(`{"username":"bad_utf","display_name":"`), 0xff, '"', '}'), + } + for _, raw := range bad { + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", nil, raw, "application/json") + if status != http.StatusBadRequest { + t.Fatalf("user body %q: %d %s", raw, status, body) + } + } + + alice := createUser(t, env, "alice", "Алиса") + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats", alice.ID, nil, []byte(`{"Title":"чат","member_ids":["`+alice.ID+`"]}`), "application/json") + if status != http.StatusBadRequest { + t.Fatalf("Title: %d %s", status, body) + } + chat := createChat(t, env, alice.ID, "чат", alice.ID) + + status, _, body = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, nil, []byte(`{"TEXT":"hi"}`), "application/json") + if status != http.StatusBadRequest { + t.Fatalf("TEXT: %d %s", status, body) + } + rawText := append([]byte(`{"text":"`), 0xff, '"', '}') + status, _, body = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, nil, rawText, "application/json") + if status != http.StatusBadRequest { + t.Fatalf("message utf-8: %d %s", status, body) + } + + status, _, body = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "one"}, nil, "") + if status != http.StatusCreated { + t.Fatalf("seed: %d %s", status, body) + } + status, _, body = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "two"}, nil, "") + if status != http.StatusCreated { + t.Fatalf("seed2: %d %s", status, body) + } + status, _, body = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1", alice.ID, nil, nil, "") + if status != http.StatusOK { + t.Fatalf("page: %d %s", status, body) + } + var page messagePage + if err := json.Unmarshal(body, &page); err != nil || page.NextCursor == nil { + t.Fatalf("cursor: %v %s", err, body) + } + decoded, err := base64.RawURLEncoding.DecodeString(*page.NextCursor) + if err != nil { + t.Fatal(err) + } + tampered := base64.RawURLEncoding.EncodeToString(append(decoded, []byte("garbage")...)) + status, _, body = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1&cursor="+url.QueryEscape(tampered), alice.ID, nil, nil, "") + if status != http.StatusBadRequest { + t.Fatalf("tampered cursor: %d %s", status, body) + } + status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=1&cursor="+url.QueryEscape(*page.NextCursor), alice.ID, nil, nil, "") + if status != http.StatusOK { + t.Fatalf("valid cursor: %d", status) + } +} + +func TestDuplicateUsername(t *testing.T) { + env := newServer(t) + createUser(t, env, "alice", "Алиса") + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/users", "", map[string]string{ + "username": "alice", "display_name": "Другая", "password": testPassword, + }, nil, "") + if status != http.StatusConflict || !bytes.Contains(body, []byte(`"conflict"`)) { + t.Fatalf("duplicate: %d %s", status, body) + } +} + +func TestEmptyMessageForeignChatAndAuth(t *testing.T) { + env := newServer(t) + alice := createUser(t, env, "alice", "Алиса") + bob := createUser(t, env, "bob", "Боб") + eve := createUser(t, env, "eve", "Ева") + chat := createChat(t, env, alice.ID, "Контрактный тест", alice.ID, bob.ID) + + status, _, _ := do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", "", nil, nil, "") + if status != http.StatusUnauthorized { + t.Fatalf("missing header: %d", status) + } + status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", "11111111-1111-4111-8111-111111111111", nil, nil, "") + if status != http.StatusUnauthorized { + t.Fatalf("unknown user: %d", status) + } + meStatus, _, meBody := do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", alice.ID, nil, nil, "") + if meStatus != http.StatusOK || !bytes.Contains(meBody, []byte(alice.ID)) { + t.Fatalf("me: %d %s", meStatus, meBody) + } + + status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID, eve.ID, nil, nil, "") + if status != http.StatusNotFound { + t.Fatalf("foreign chat: %d", status) + } + status, _, _ = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", eve.ID, map[string]string{"text": "чужое"}, nil, "") + if status != http.StatusNotFound { + t.Fatalf("foreign post: %d", status) + } + for _, text := range []string{"", " ", "\n\t"} { + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": text}, nil, "") + if status != http.StatusBadRequest { + t.Fatalf("empty %q: %d %s", text, status, body) + } + } + status, _, _ = do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": "привет", "sender_id": eve.ID}, nil, "") + if status != http.StatusBadRequest { + t.Fatalf("sender_id must be rejected: %d", status) + } + + text := "Привет, мир 👋" + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", alice.ID, map[string]string{"text": text}, nil, "") + if status != http.StatusCreated { + t.Fatalf("unicode: %d %s", status, body) + } + var msg messageJSON + if err := json.Unmarshal(body, &msg); err != nil { + t.Fatal(err) + } + if msg.Text != text || msg.SenderID != alice.ID || msg.ChatID != chat.ID { + t.Fatalf("message mutated: %+v", msg) + } + if !strings.HasSuffix(msg.CreatedAt, "Z") { + t.Fatalf("timestamp: %s", msg.CreatedAt) + } +} + +func TestPaginationSeveralPages(t *testing.T) { + env := newServer(t) + alice := createUser(t, env, "alice", "Алиса") + bob := createUser(t, env, "bob", "Боб") + chat := createChat(t, env, alice.ID, "страницы", alice.ID, bob.ID) + other := createChat(t, env, alice.ID, "другой", alice.ID) + const n = 25 + ids := make([]string, 0, n) + for i := 0; i < n; i++ { + sender := alice.ID + if i%2 == 1 { + sender = bob.ID + } + status, _, body := do(t, env, http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", sender, map[string]string{ + "text": "сообщение " + strings.Repeat("я", i%3) + string(rune('a'+i%26)), + }, nil, "") + if status != http.StatusCreated { + t.Fatalf("post %d: %d %s", i, status, body) + } + var msg messageJSON + if err := json.Unmarshal(body, &msg); err != nil { + t.Fatal(err) + } + ids = append(ids, msg.ID) + } + var got []string + cursor := "" + pages := 0 + for { + pages++ + if pages > 10 { + t.Fatal("pagination did not finish") + } + url := env.URL + "/api/v1/chats/" + chat.ID + "/messages?limit=10" + if cursor != "" { + url += "&cursor=" + cursor + } + status, _, body := do(t, env, http.MethodGet, url, bob.ID, nil, nil, "") + if status != http.StatusOK { + t.Fatalf("page: %d %s", status, body) + } + var page messagePage + if err := json.Unmarshal(body, &page); err != nil { + t.Fatal(err) + } + if len(page.Items) == 0 || len(page.Items) > 10 { + t.Fatalf("page size %d", len(page.Items)) + } + for _, item := range page.Items { + got = append(got, item.ID) + } + if page.NextCursor == nil { + break + } + cursor = *page.NextCursor + } + if pages < 3 { + t.Fatalf("expected several pages, got %d", pages) + } + if strings.Join(got, ",") != strings.Join(ids, ",") { + t.Fatalf("order/duplication mismatch\nwant %v\ngot %v", ids, got) + } + status, _, _ := do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+other.ID+"/messages?limit=10&cursor="+cursor, alice.ID, nil, nil, "") + if status != http.StatusBadRequest { + t.Fatalf("foreign cursor: %d", status) + } + status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/chats/"+chat.ID+"/messages?limit=0", alice.ID, nil, nil, "") + if status != http.StatusBadRequest { + t.Fatalf("limit 0: %d", status) + } +} + +func TestConcurrentHundredMessages(t *testing.T) { + env := newServer(t) + users := make([]userJSON, 10) + ids := make([]string, 10) + for i := 0; i < 10; i++ { + users[i] = createUser(t, env, "u"+string(rune('a'+i))+"x", "Участник") + ids[i] = users[i].ID + } + chat := createChat(t, env, ids[0], "гонка", ids...) + var wg sync.WaitGroup + errCh := make(chan error, 100) + for i := 0; i < 10; i++ { + wg.Add(1) + go func(user string) { + defer wg.Done() + for j := 0; j < 10; j++ { + req, err := http.NewRequest(http.MethodPost, env.URL+"/api/v1/chats/"+chat.ID+"/messages", strings.NewReader(`{"text":"n"}`)) + if err != nil { + errCh <- err + return + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("Authorization", "Bearer "+env.tokens[user]) + resp, err := http.DefaultClient.Do(req) + if err != nil { + errCh <- err + return + } + body, _ := io.ReadAll(resp.Body) + resp.Body.Close() + if resp.StatusCode != http.StatusCreated { + errCh <- &statusErr{resp.StatusCode, body} + } + } + }(ids[i]) + } + wg.Wait() + close(errCh) + for err := range errCh { + t.Fatal(err) + } + seen := map[string]struct{}{} + cursor := "" + for { + url := env.URL + "/api/v1/chats/" + chat.ID + "/messages?limit=17" + if cursor != "" { + url += "&cursor=" + cursor + } + status, _, body := do(t, env, http.MethodGet, url, ids[3], nil, nil, "") + if status != http.StatusOK { + t.Fatalf("list: %d %s", status, body) + } + var page messagePage + if err := json.Unmarshal(body, &page); err != nil { + t.Fatal(err) + } + for _, item := range page.Items { + if _, ok := seen[item.ID]; ok { + t.Fatalf("duplicate %s", item.ID) + } + seen[item.ID] = struct{}{} + } + if page.NextCursor == nil { + break + } + cursor = *page.NextCursor + } + if len(seen) != 100 { + t.Fatalf("unique messages = %d, want 100", len(seen)) + } +} + +func TestSessionWrongPasswordLogoutAndIgnoredUserHeader(t *testing.T) { + env := newServer(t) + alice := createUser(t, env, "alice", "Алиса") + eve := createUser(t, env, "eve", "Ева") + + req, err := http.NewRequest(http.MethodPost, env.URL+"/api/v1/auth/sessions", nil) + if err != nil { + t.Fatal(err) + } + req.SetBasicAuth("alice", "wrong-password-1") + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatal(err) + } + body, _ := io.ReadAll(resp.Body) + resp.Body.Close() + if resp.StatusCode != http.StatusUnauthorized || !strings.HasPrefix(resp.Header.Get("WWW-Authenticate"), "Basic ") { + t.Fatalf("wrong password: %d %s %q", resp.StatusCode, body, resp.Header.Get("WWW-Authenticate")) + } + + status, hdr, _ := do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", "", nil, nil, "") + if status != http.StatusUnauthorized || !strings.HasPrefix(hdr.Get("WWW-Authenticate"), "Bearer ") { + t.Fatalf("missing bearer: %d %q", status, hdr.Get("WWW-Authenticate")) + } + bare, err := http.NewRequest(http.MethodGet, env.URL+"/api/v1/users/me", nil) + if err != nil { + t.Fatal(err) + } + bare.Header.Set("X-User-Id", alice.ID) + resp, err = http.DefaultClient.Do(bare) + if err != nil { + t.Fatal(err) + } + resp.Body.Close() + if resp.StatusCode != http.StatusUnauthorized { + t.Fatalf("X-User-Id alone: %d", resp.StatusCode) + } + over, err := http.NewRequest(http.MethodGet, env.URL+"/api/v1/users/me", nil) + if err != nil { + t.Fatal(err) + } + over.Header.Set("Authorization", "Bearer "+env.tokens[alice.ID]) + over.Header.Set("X-User-Id", eve.ID) + resp, err = http.DefaultClient.Do(over) + if err != nil { + t.Fatal(err) + } + raw, _ := io.ReadAll(resp.Body) + resp.Body.Close() + if resp.StatusCode != http.StatusOK || !bytes.Contains(raw, []byte(alice.ID)) || bytes.Contains(raw, []byte(eve.ID)) { + t.Fatalf("X-User-Id overrode bearer: %d %s", resp.StatusCode, raw) + } + + basic, err := http.NewRequest(http.MethodGet, env.URL+"/api/v1/users/me", nil) + if err != nil { + t.Fatal(err) + } + basic.SetBasicAuth("alice", testPassword) + resp, err = http.DefaultClient.Do(basic) + if err != nil { + t.Fatal(err) + } + resp.Body.Close() + if resp.StatusCode != http.StatusUnauthorized || !strings.HasPrefix(resp.Header.Get("WWW-Authenticate"), "Bearer ") { + t.Fatalf("basic on business endpoint: %d", resp.StatusCode) + } + + status, _, body = do(t, env, http.MethodDelete, env.URL+"/api/v1/auth/sessions/current", alice.ID, nil, nil, "") + if status != http.StatusNoContent || len(body) != 0 { + t.Fatalf("logout: %d %q", status, body) + } + status, _, _ = do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", alice.ID, nil, nil, "") + if status != http.StatusUnauthorized { + t.Fatalf("revoked token: %d", status) + } + status, _, _ = do(t, env, http.MethodDelete, env.URL+"/api/v1/auth/sessions/current", alice.ID, nil, nil, "") + if status != http.StatusUnauthorized { + t.Fatalf("second logout: %d", status) + } +} + +func TestSessionExpires(t *testing.T) { + env := newServerTTL(t, 2*time.Second) + alice := createUser(t, env, "alice", "Алиса") + time.Sleep(2100 * time.Millisecond) + status, _, _ := do(t, env, http.MethodGet, env.URL+"/api/v1/users/me", alice.ID, nil, nil, "") + if status != http.StatusUnauthorized { + t.Fatalf("expired session: %d", status) + } +} + +type downSessions struct{ session.Store } + +func (downSessions) Lookup(context.Context, string) (string, time.Time, error) { + return "", time.Time{}, session.ErrUnavailable +} +func (downSessions) Ping(context.Context) error { return session.ErrUnavailable } + +type downStore struct{ store.Repository } + +func (downStore) Ping(context.Context) error { return store.ErrUnavailable } +func (downStore) User(context.Context, string) (store.User, error) { + return store.User{}, store.ErrUnavailable +} + +func TestDependencyDownDoesNotTrustAnonymous(t *testing.T) { + env := newServer(t) + alice := createUser(t, env, "alice", "Алиса") + broken := New(downStore{env.store}, downSessions{env.sess}, password.Params{Time: 1, Memory: 8, Threads: 1}, time.Hour, slog.New(slog.NewJSONHandler(io.Discard, nil))) + srv := httptest.NewServer(broken) + defer srv.Close() + + live, err := http.Get(srv.URL + "/health/live") + if err != nil { + t.Fatal(err) + } + live.Body.Close() + if live.StatusCode != http.StatusOK { + t.Fatalf("live: %d", live.StatusCode) + } + ready, err := http.Get(srv.URL + "/health/ready") + if err != nil { + t.Fatal(err) + } + readyBody, _ := io.ReadAll(ready.Body) + ready.Body.Close() + if ready.StatusCode != http.StatusServiceUnavailable || !bytes.Contains(readyBody, []byte(`"unavailable"`)) { + t.Fatalf("ready: %d %s", ready.StatusCode, readyBody) + } + + anon, err := http.Get(srv.URL + "/api/v1/users/me") + if err != nil { + t.Fatal(err) + } + anon.Body.Close() + if anon.StatusCode != http.StatusUnauthorized { + t.Fatalf("anonymous while down: %d", anon.StatusCode) + } + authed, err := http.NewRequest(http.MethodGet, srv.URL+"/api/v1/users/me", nil) + if err != nil { + t.Fatal(err) + } + authed.Header.Set("Authorization", "Bearer "+env.tokens[alice.ID]) + resp, err := http.DefaultClient.Do(authed) + if err != nil { + t.Fatal(err) + } + resp.Body.Close() + if resp.StatusCode != http.StatusServiceUnavailable { + t.Fatalf("bearer while session store is down: %d", resp.StatusCode) + } +} + +type statusErr struct { + code int + body []byte +} + +func (e *statusErr) Error() string { + return http.StatusText(e.code) + " " + string(e.body) +} diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..603a00ea --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,116 @@ +package config + +import ( + "fmt" + "net" + "os" + "strconv" + "time" +) + +// Config — параметры процесса. Секреты приходят из окружения, не из образа. +type Config struct { + Host string + Port string + Env string + ShutdownTimeout time.Duration + DatabaseURL string + RedisURL string + SessionTTL time.Duration + DBMaxConns int32 + Argon2Time uint32 + Argon2Memory uint32 + Argon2Threads uint8 +} + +// Addr — адрес прослушивания. В контейнере это 0.0.0.0:8080, +// иначе published port Docker не попадёт в процесс. +func (c Config) Addr() string { + return net.JoinHostPort(c.Host, c.Port) +} + +// Load завершает запуск ошибкой, если значение вне допустимого диапазона. +func Load() (Config, error) { + var c Config + c.Host = getenv("APP_HOST", "0.0.0.0") + c.Port = getenv("APP_PORT", "8080") + c.Env = getenv("APP_ENV", "lab") + if c.Host == "" { + return Config{}, fmt.Errorf("APP_HOST is empty") + } + port, err := strconv.Atoi(c.Port) + if err != nil || port < 1 || port > 65535 { + return Config{}, fmt.Errorf("APP_PORT must be 1..65535") + } + + sec, err := nonNeg("SHUTDOWN_TIMEOUT_SECONDS", 8) + if err != nil { + return Config{}, err + } + if sec < 1 || sec > 10 { + return Config{}, fmt.Errorf("SHUTDOWN_TIMEOUT_SECONDS must be 1..10") + } + c.ShutdownTimeout = time.Duration(sec) * time.Second + + c.DatabaseURL = getenv("DATABASE_URL", "") + c.RedisURL = getenv("REDIS_URL", "") + if c.DatabaseURL == "" || c.RedisURL == "" { + return Config{}, fmt.Errorf("DATABASE_URL and REDIS_URL are required") + } + ttl, err := nonNeg("SESSION_TTL_SECONDS", 3600) + if err != nil { + return Config{}, err + } + if ttl < 1 || ttl > 7*24*3600 { + return Config{}, fmt.Errorf("SESSION_TTL_SECONDS must be 1..604800") + } + c.SessionTTL = time.Duration(ttl) * time.Second + + maxConns, err := nonNeg("DB_MAX_CONNS", 10) + if err != nil { + return Config{}, err + } + if maxConns < 1 || maxConns > 50 { + return Config{}, fmt.Errorf("DB_MAX_CONNS must be 1..50") + } + c.DBMaxConns = int32(maxConns) + + argonTime, err := nonNeg("ARGON2_TIME", 2) + if err != nil { + return Config{}, err + } + argonMemory, err := nonNeg("ARGON2_MEMORY_KIB", 19456) + if err != nil { + return Config{}, err + } + argonThreads, err := nonNeg("ARGON2_THREADS", 1) + if err != nil { + return Config{}, err + } + if argonTime < 1 || argonTime > 10 || argonMemory < 8 || argonMemory > 1<<20 || argonThreads < 1 || argonThreads > 8 { + return Config{}, fmt.Errorf("argon2 params are out of range") + } + c.Argon2Time = uint32(argonTime) + c.Argon2Memory = uint32(argonMemory) + c.Argon2Threads = uint8(argonThreads) + return c, nil +} + +func getenv(key, def string) string { + if v, ok := os.LookupEnv(key); ok && v != "" { + return v + } + return def +} + +func nonNeg(key string, def int) (int, error) { + v, ok := os.LookupEnv(key) + if !ok || v == "" { + return def, nil + } + n, err := strconv.Atoi(v) + if err != nil || n < 0 { + return 0, fmt.Errorf("%s must be a non-negative integer", key) + } + return n, nil +} diff --git a/internal/migrate/migrate.go b/internal/migrate/migrate.go new file mode 100644 index 00000000..79b339d4 --- /dev/null +++ b/internal/migrate/migrate.go @@ -0,0 +1,68 @@ +// применяет SQL из бинарника ровно один раз на файл. +package migrate + +import ( + "context" + "fmt" + "io/fs" + "sort" + "strings" + + "github.com/jackc/pgx/v5/pgxpool" + + "messenger/migrations" +) + +// Создаёт schema_migrations и выполняет ещё не записанные файлы. +// Повторный запуск не исполняет уже применённый SQL и не дублирует строки. +func Apply(ctx context.Context, pool *pgxpool.Pool) error { + _, err := pool.Exec(ctx, ` + CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT now() + )`) + if err != nil { + return fmt.Errorf("schema_migrations: %w", err) + } + entries, err := fs.ReadDir(migrations.FS, ".") + if err != nil { + return err + } + names := make([]string, 0, len(entries)) + for _, entry := range entries { + if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".sql") { + continue + } + names = append(names, entry.Name()) + } + sort.Strings(names) + for _, name := range names { + var applied bool + if err := pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM schema_migrations WHERE version = $1)`, name).Scan(&applied); err != nil { + return err + } + if applied { + continue + } + body, err := fs.ReadFile(migrations.FS, name) + if err != nil { + return err + } + tx, err := pool.Begin(ctx) + if err != nil { + return err + } + if _, err := tx.Exec(ctx, string(body)); err != nil { + _ = tx.Rollback(ctx) + return fmt.Errorf("%s: %w", name, err) + } + if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version) VALUES ($1)`, name); err != nil { + _ = tx.Rollback(ctx) + return err + } + if err := tx.Commit(ctx); err != nil { + return err + } + } + return nil +} diff --git a/internal/password/password.go b/internal/password/password.go new file mode 100644 index 00000000..20fcd85b --- /dev/null +++ b/internal/password/password.go @@ -0,0 +1,65 @@ +// Package password хеширует пароли Argon2id. +// SHA-256 здесь не подходит: он быстрый, и его можно перебирать. +// bcrypt не берём: библиотеки часто режут пароль до 72 байт и ломают длинный UTF-8. +package password + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "fmt" + "strings" + + "golang.org/x/crypto/argon2" +) + +// Params — стоимость KDF. Значения пишутся в саму строку хеша, +// поэтому старые пароли проверяются даже после смены настроек. +type Params struct { + Time uint32 + Memory uint32 + Threads uint8 +} + +// Hash возвращает PHC-строку. Соль случайная на каждый пароль. +func (p Params) Hash(plain string) (string, error) { + if p.Time < 1 || p.Threads < 1 || p.Memory < 8*uint32(p.Threads) { + return "", fmt.Errorf("argon2 params are too small") + } + salt := make([]byte, 16) + if _, err := rand.Read(salt); err != nil { + return "", err + } + sum := argon2.IDKey([]byte(plain), salt, p.Time, p.Memory, p.Threads, 32) + return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, + p.Memory, p.Time, p.Threads, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(sum), + ), nil +} + +// Verify сравнивает пароль с PHC-строкой. Параметры берутся из строки, не из текущего конфига. +func Verify(plain, encoded string) bool { + parts := strings.Split(encoded, "$") + if len(parts) != 6 || parts[1] != "argon2id" || !strings.HasPrefix(parts[2], "v=") { + return false + } + var memory, timeCost, threads int + if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil { + return false + } + if memory < 8 || timeCost < 1 || threads < 1 || threads > 255 { + return false + } + salt, err := base64.RawStdEncoding.DecodeString(parts[4]) + if err != nil || len(salt) == 0 { + return false + } + want, err := base64.RawStdEncoding.DecodeString(parts[5]) + if err != nil || len(want) == 0 { + return false + } + got := argon2.IDKey([]byte(plain), salt, uint32(timeCost), uint32(memory), uint8(threads), uint32(len(want))) + return subtle.ConstantTimeCompare(got, want) == 1 +} diff --git a/internal/password/password_test.go b/internal/password/password_test.go new file mode 100644 index 00000000..51b654fd --- /dev/null +++ b/internal/password/password_test.go @@ -0,0 +1,23 @@ +package password + +import "testing" + +func TestArgon2idRoundTrip(t *testing.T) { + p := Params{Time: 1, Memory: 8, Threads: 1} + encoded, err := p.Hash("correct-horse-1") + if err != nil { + t.Fatal(err) + } + if encoded == "correct-horse-1" || len(encoded) < 20 { + t.Fatalf("hash is not a PHC string: %s", encoded) + } + if !Verify("correct-horse-1", encoded) { + t.Fatal("matching password rejected") + } + if Verify("other-password-1", encoded) { + t.Fatal("wrong password accepted") + } + if Verify("correct-horse-1", "sha256:deadbeef") { + t.Fatal("non-argon string accepted") + } +} diff --git a/internal/session/redis_test.go b/internal/session/redis_test.go new file mode 100644 index 00000000..a7108f9b --- /dev/null +++ b/internal/session/redis_test.go @@ -0,0 +1,77 @@ +package session + +import ( + "context" + "errors" + "os" + "testing" + "time" +) + +func TestMemoryExpiryAndRevoke(t *testing.T) { + s := NewMemory() + ctx := context.Background() + exp := time.Now().Add(30 * time.Millisecond) + if err := s.Create(ctx, "token-value-with-enough-entropy-xx", "user-1", exp); err != nil { + t.Fatal(err) + } + if _, _, err := s.Lookup(ctx, "token-value-with-enough-entropy-xx"); err != nil { + t.Fatal(err) + } + time.Sleep(40 * time.Millisecond) + if _, _, err := s.Lookup(ctx, "token-value-with-enough-entropy-xx"); !errors.Is(err, ErrNotFound) { + t.Fatalf("expired: %v", err) + } + exp = time.Now().Add(time.Minute) + if err := s.Create(ctx, "token-value-with-enough-entropy-yy", "user-1", exp); err != nil { + t.Fatal(err) + } + if err := s.Revoke(ctx, "token-value-with-enough-entropy-yy"); err != nil { + t.Fatal(err) + } + if _, _, err := s.Lookup(ctx, "token-value-with-enough-entropy-yy"); !errors.Is(err, ErrNotFound) { + t.Fatalf("revoked: %v", err) + } +} + +func TestRedisDown(t *testing.T) { + s, err := OpenRedis("redis://127.0.0.1:1/0") + if err != nil { + t.Fatal(err) + } + defer s.Close() + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + defer cancel() + if err := s.Ping(ctx); !errors.Is(err, ErrUnavailable) { + t.Fatalf("ping: %v", err) + } + if err := s.Create(ctx, "token", "user", time.Now().Add(time.Minute)); !errors.Is(err, ErrUnavailable) { + t.Fatalf("create: %v", err) + } +} + +func TestIntegrationRedisRoundTrip(t *testing.T) { + raw := os.Getenv("REDIS_URL") + if raw == "" { + t.Skip("REDIS_URL is not set") + } + s, err := OpenRedis(raw) + if err != nil { + t.Fatal(err) + } + defer s.Close() + ctx := context.Background() + token := "integration-token-" + time.Now().UTC().Format("150405.000000") + exp := time.Now().UTC().Add(2 * time.Second).Truncate(time.Microsecond) + if err := s.Create(ctx, token, "11111111-1111-4111-8111-111111111111", exp); err != nil { + t.Fatal(err) + } + id, got, err := s.Lookup(ctx, token) + if err != nil || id != "11111111-1111-4111-8111-111111111111" || !got.Equal(exp) { + t.Fatalf("lookup id=%s exp=%s err=%v", id, got, err) + } + time.Sleep(2200 * time.Millisecond) + if _, _, err := s.Lookup(ctx, token); !errors.Is(err, ErrNotFound) { + t.Fatalf("ttl did not expire: %v", err) + } +} diff --git a/internal/session/session.go b/internal/session/session.go new file mode 100644 index 00000000..413b6a19 --- /dev/null +++ b/internal/session/session.go @@ -0,0 +1,175 @@ +// Package session хранит непрозрачные Bearer-сессии. +// В стенде это Redis: ключ живёт ровно до expires_at, рестарт TTL не сдвигает. +package session + +import ( + "context" + "crypto/sha256" + "encoding/hex" + "encoding/json" + "errors" + "sync" + "time" + + "github.com/redis/go-redis/v9" +) + +var ( + ErrNotFound = errors.New("session not found") + ErrUnavailable = errors.New("session store unavailable") +) + +// Store — срок жизни сессии задаёт вызывающий, хранилище его не продлевает. +type Store interface { + Create(ctx context.Context, token, userID string, expiresAt time.Time) error + Lookup(ctx context.Context, token string) (userID string, expiresAt time.Time, err error) + Revoke(ctx context.Context, token string) error + Ping(ctx context.Context) error + Close() error +} + +type record struct { + UserID string `json:"user_id"` + ExpUnix int64 `json:"exp_unix"` +} + +// key — хеш токена. Сам токен в Redis не пишется: утечка дампа не равна утечке Bearer. +func key(token string) string { + sum := sha256.Sum256([]byte(token)) + return "sess:" + hex.EncodeToString(sum[:]) +} + +// Memory — сессии процесса. Нужна юнит-тестам без Docker. +type Memory struct { + mu sync.Mutex + items map[string]record +} + +func NewMemory() *Memory { + return &Memory{items: make(map[string]record)} +} + +func (m *Memory) Create(_ context.Context, token, userID string, expiresAt time.Time) error { + if token == "" || userID == "" { + return ErrNotFound + } + m.mu.Lock() + defer m.mu.Unlock() + m.items[key(token)] = record{UserID: userID, ExpUnix: expiresAt.UTC().UnixMicro()} + return nil +} + +func (m *Memory) Lookup(_ context.Context, token string) (string, time.Time, error) { + m.mu.Lock() + defer m.mu.Unlock() + rec, ok := m.items[key(token)] + if !ok { + return "", time.Time{}, ErrNotFound + } + exp := time.UnixMicro(rec.ExpUnix).UTC() + if !time.Now().Before(exp) { + delete(m.items, key(token)) + return "", time.Time{}, ErrNotFound + } + return rec.UserID, exp, nil +} + +func (m *Memory) Revoke(_ context.Context, token string) error { + m.mu.Lock() + defer m.mu.Unlock() + k := key(token) + if _, ok := m.items[k]; !ok { + return ErrNotFound + } + delete(m.items, k) + return nil +} + +func (m *Memory) Ping(ctx context.Context) error { + if err := ctx.Err(); err != nil { + return ErrUnavailable + } + return nil +} + +func (m *Memory) Close() error { return nil } + +// Redis — единственное хранилище сессий стенда. +// TTL ключа равен остатку до expires_at. AOF на стороне сервера переживает рестарт процесса Redis; +// одного EXPIRE без persistence было бы мало: после рестарта ключ исчез бы. +type Redis struct { + client *redis.Client +} + +func OpenRedis(rawURL string) (*Redis, error) { + opt, err := redis.ParseURL(rawURL) + if err != nil { + return nil, err + } + opt.DialTimeout = 500 * time.Millisecond + opt.ReadTimeout = 500 * time.Millisecond + opt.WriteTimeout = 500 * time.Millisecond + opt.PoolSize = 10 + opt.MinIdleConns = 1 + return &Redis{client: redis.NewClient(opt)}, nil +} + +func (r *Redis) Create(ctx context.Context, token, userID string, expiresAt time.Time) error { + if token == "" || userID == "" { + return ErrNotFound + } + ttl := time.Until(expiresAt) + if ttl < time.Millisecond { + return ErrNotFound + } + body, err := json.Marshal(record{UserID: userID, ExpUnix: expiresAt.UTC().UnixMicro()}) + if err != nil { + return err + } + if err := r.client.Set(ctx, key(token), body, ttl).Err(); err != nil { + return ErrUnavailable + } + return nil +} + +func (r *Redis) Lookup(ctx context.Context, token string) (string, time.Time, error) { + raw, err := r.client.Get(ctx, key(token)).Bytes() + if errors.Is(err, redis.Nil) { + return "", time.Time{}, ErrNotFound + } + if err != nil { + return "", time.Time{}, ErrUnavailable + } + var rec record + if err := json.Unmarshal(raw, &rec); err != nil || rec.UserID == "" { + return "", time.Time{}, ErrNotFound + } + exp := time.UnixMicro(rec.ExpUnix).UTC() + if !time.Now().Before(exp) { + _ = r.client.Del(ctx, key(token)).Err() + return "", time.Time{}, ErrNotFound + } + return rec.UserID, exp, nil +} + +func (r *Redis) Revoke(ctx context.Context, token string) error { + n, err := r.client.Del(ctx, key(token)).Result() + if err != nil { + return ErrUnavailable + } + if n == 0 { + return ErrNotFound + } + return nil +} + +func (r *Redis) Ping(ctx context.Context) error { + if err := r.client.Ping(ctx).Err(); err != nil { + return ErrUnavailable + } + return nil +} + +func (r *Redis) Close() error { + return r.client.Close() +} diff --git a/internal/store/postgres.go b/internal/store/postgres.go new file mode 100644 index 00000000..6f2843f1 --- /dev/null +++ b/internal/store/postgres.go @@ -0,0 +1,390 @@ +package store + +import ( + "context" + "errors" + "net" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" +) + +// PG — источник истины для пользователей, чатов и сообщений. +// Запросы только с параметрами. Пул ограничен, у сессии соединения есть statement_timeout. +type PG struct { + pool *pgxpool.Pool +} + +func Open(ctx context.Context, databaseURL string, maxConns int32) (*PG, error) { + cfg, err := pgxpool.ParseConfig(databaseURL) + if err != nil { + return nil, err + } + if maxConns < 1 { + maxConns = 10 + } + cfg.MaxConns = maxConns + cfg.MinConns = 1 + cfg.MaxConnLifetime = 30 * time.Minute + cfg.MaxConnIdleTime = 5 * time.Minute + cfg.HealthCheckPeriod = 30 * time.Second + cfg.ConnConfig.ConnectTimeout = 3 * time.Second + cfg.ConnConfig.RuntimeParams["application_name"] = "messenger" + cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000" + cfg.ConnConfig.RuntimeParams["lock_timeout"] = "3000" + cfg.ConnConfig.RuntimeParams["idle_in_transaction_session_timeout"] = "10000" + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + return nil, err + } + pingCtx, cancel := context.WithTimeout(ctx, 3*time.Second) + defer cancel() + if err := pool.Ping(pingCtx); err != nil { + pool.Close() + return nil, err + } + return &PG{pool: pool}, nil +} + +func (p *PG) Close() { p.pool.Close() } + +func (p *PG) Pool() *pgxpool.Pool { return p.pool } + +func (p *PG) Ping(ctx context.Context) error { + return mapDB(p.pool.Ping(ctx)) +} + +func (p *PG) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) { + u := User{ + ID: newID(), + Username: username, + DisplayName: displayName, + CreatedAt: time.Now().UTC().Truncate(time.Microsecond), + } + _, err := p.pool.Exec(ctx, ` + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1, $2, $3, $4, $5)`, + u.ID, u.Username, u.DisplayName, passwordHash, u.CreatedAt) + if err != nil { + return User{}, mapDB(err) + } + return u, nil +} + +func (p *PG) User(ctx context.Context, id string) (User, error) { + row := p.pool.QueryRow(ctx, ` + SELECT id::text, username, display_name, created_at + FROM users WHERE id = $1`, id) + return scanUser(row) +} + +func (p *PG) UserByUsername(ctx context.Context, username string) (User, string, error) { + var u User + var hash string + err := p.pool.QueryRow(ctx, ` + SELECT id::text, username, display_name, created_at, password_hash + FROM users WHERE username = $1`, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash) + if err != nil { + return User{}, "", mapDB(err) + } + u.CreatedAt = u.CreatedAt.UTC() + return u, hash, nil +} + +// CreateChat пишет чат и всех участников в одной транзакции. +// Если кого-то из списка нет, COMMIT не случается и строка чата не остаётся. +func (p *PG) CreateChat(ctx context.Context, title string, memberIDs []string, caller string) (Chat, error) { + seen := make(map[string]struct{}, len(memberIDs)) + for _, id := range memberIDs { + if _, dup := seen[id]; dup { + return Chat{}, ErrInvalid + } + seen[id] = struct{}{} + } + if _, ok := seen[caller]; !ok { + return Chat{}, ErrInvalid + } + tx, err := p.pool.Begin(ctx) + if err != nil { + return Chat{}, mapDB(err) + } + defer func() { _ = tx.Rollback(ctx) }() + + c := Chat{ + ID: newID(), + Title: title, + MemberIDs: append([]string(nil), memberIDs...), + CreatedAt: time.Now().UTC().Truncate(time.Microsecond), + } + if _, err := tx.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`, c.ID, c.Title, c.CreatedAt); err != nil { + return Chat{}, mapDB(err) + } + var n int + if err := tx.QueryRow(ctx, `SELECT count(*) FROM users WHERE id::text = ANY($1::text[])`, memberIDs).Scan(&n); err != nil { + return Chat{}, mapDB(err) + } + if n != len(memberIDs) { + return Chat{}, ErrInvalid + } + for i, id := range memberIDs { + if _, err := tx.Exec(ctx, ` + INSERT INTO chat_members (chat_id, user_id, position) VALUES ($1, $2, $3)`, + c.ID, id, i); err != nil { + return Chat{}, mapDB(err) + } + } + if err := tx.Commit(ctx); err != nil { + return Chat{}, mapDB(err) + } + return c, nil +} + +func (p *PG) ChatFor(ctx context.Context, chatID, userID string) (Chat, error) { + var c Chat + err := p.pool.QueryRow(ctx, ` + SELECT c.id::text, 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, &c.CreatedAt) + if err != nil { + return Chat{}, mapDB(err) + } + c.CreatedAt = c.CreatedAt.UTC() + ids, err := p.memberIDs(ctx, p.pool, []string{c.ID}) + if err != nil { + return Chat{}, err + } + c.MemberIDs = ids[c.ID] + if c.MemberIDs == nil { + c.MemberIDs = []string{} + } + return c, nil +} + +func (p *PG) ListChats(ctx context.Context, userID string, cur *Cursor, limit int) ([]Chat, bool, error) { + hasCursor := cur != nil + at := time.Time{} + var id any + if hasCursor { + at = cur.At + id = cur.ID + } + rows, err := p.pool.Query(ctx, ` + SELECT c.id::text, c.title, c.created_at + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $1 + WHERE NOT $2::bool OR (c.created_at, c.id) > ($3::timestamptz, $4::uuid) + ORDER BY c.created_at, c.id + LIMIT $5`, userID, hasCursor, at, id, limit+1) + if err != nil { + return nil, false, mapDB(err) + } + defer rows.Close() + items := make([]Chat, 0) + ids := make([]string, 0) + for rows.Next() { + var c Chat + if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil { + return nil, false, mapDB(err) + } + c.CreatedAt = c.CreatedAt.UTC() + items = append(items, c) + ids = append(ids, c.ID) + } + if err := rows.Err(); err != nil { + return nil, false, mapDB(err) + } + hasMore := len(items) > limit + if hasMore { + items = items[:limit] + ids = ids[:limit] + } + members, err := p.memberIDs(ctx, p.pool, ids) + if err != nil { + return nil, false, err + } + for i := range items { + items[i].MemberIDs = members[items[i].ID] + if items[i].MemberIDs == nil { + items[i].MemberIDs = []string{} + } + } + return items, hasMore, nil +} + +func (p *PG) AddMessage(ctx context.Context, chatID, senderID, text string) (Message, error) { + tx, err := p.pool.Begin(ctx) + if err != nil { + return Message{}, mapDB(err) + } + defer func() { _ = tx.Rollback(ctx) }() + + // Блокировка строки чата сериализует writers одного чата. + // Иначе два COMMIT с одним created_at упорядочились бы случайным UUID, а не фактом записи. + var exists string + err = tx.QueryRow(ctx, `SELECT id::text FROM chats WHERE id = $1 FOR UPDATE`, chatID).Scan(&exists) + if err != nil { + return Message{}, mapDB(err) + } + var member int + if err := tx.QueryRow(ctx, ` + SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, senderID).Scan(&member); err != nil { + return Message{}, mapDB(err) + } + var last time.Time + err = tx.QueryRow(ctx, ` + SELECT created_at FROM messages WHERE chat_id = $1 + ORDER BY created_at DESC LIMIT 1`, chatID).Scan(&last) + if errors.Is(err, pgx.ErrNoRows) { + last = time.Time{} + } else if err != nil { + return Message{}, mapDB(err) + } + now := time.Now().UTC().Truncate(time.Microsecond) + if !last.IsZero() && !now.After(last.UTC()) { + now = last.UTC().Add(time.Microsecond) + } + m := Message{ + ID: newID(), + ChatID: chatID, + SenderID: senderID, + Text: text, + CreatedAt: now, + } + if _, err := tx.Exec(ctx, ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1, $2, $3, $4, $5)`, m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt); err != nil { + return Message{}, mapDB(err) + } + if err := tx.Commit(ctx); err != nil { + return Message{}, mapDB(err) + } + return m, nil +} + +func (p *PG) ListMessages(ctx context.Context, chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error) { + var member int + err := p.pool.QueryRow(ctx, ` + SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, userID).Scan(&member) + if err != nil { + return nil, false, mapDB(err) + } + if cur != nil { + var one int + err := p.pool.QueryRow(ctx, ` + SELECT 1 FROM messages + WHERE chat_id = $1 AND id = $2 AND created_at = $3`, chatID, cur.ID, cur.At).Scan(&one) + if errors.Is(err, pgx.ErrNoRows) { + return nil, false, ErrBadCursor + } + if err != nil { + return nil, false, mapDB(err) + } + } + hasCursor := cur != nil + at := time.Time{} + var id any + if hasCursor { + at = cur.At + id = cur.ID + } + rows, err := p.pool.Query(ctx, ` + SELECT id::text, chat_id::text, sender_id::text, text, created_at + FROM messages + WHERE chat_id = $1 + AND (NOT $2::bool OR (created_at, id) > ($3::timestamptz, $4::uuid)) + ORDER BY created_at, id + LIMIT $5`, chatID, hasCursor, at, id, limit+1) + if err != nil { + return nil, false, mapDB(err) + } + defer rows.Close() + items := make([]Message, 0) + for rows.Next() { + var m Message + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil { + return nil, false, mapDB(err) + } + m.CreatedAt = m.CreatedAt.UTC() + items = append(items, m) + } + if err := rows.Err(); err != nil { + return nil, false, mapDB(err) + } + hasMore := len(items) > limit + if hasMore { + items = items[:limit] + } + return items, hasMore, nil +} + +type queryer interface { + Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error) +} + +func (p *PG) memberIDs(ctx context.Context, q queryer, chatIDs []string) (map[string][]string, error) { + out := make(map[string][]string, len(chatIDs)) + if len(chatIDs) == 0 { + return out, nil + } + rows, err := q.Query(ctx, ` + SELECT chat_id::text, user_id::text + FROM chat_members + WHERE chat_id::text = ANY($1::text[]) + ORDER BY chat_id, position`, chatIDs) + if err != nil { + return nil, mapDB(err) + } + defer rows.Close() + for rows.Next() { + var chatID, userID string + if err := rows.Scan(&chatID, &userID); err != nil { + return nil, mapDB(err) + } + out[chatID] = append(out[chatID], userID) + } + if err := rows.Err(); err != nil { + return nil, mapDB(err) + } + return out, nil +} + +func scanUser(row pgx.Row) (User, error) { + var u User + err := row.Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if err != nil { + return User{}, mapDB(err) + } + u.CreatedAt = u.CreatedAt.UTC() + return u, nil +} + +func mapDB(err error) error { + if err == nil { + return nil + } + if errors.Is(err, pgx.ErrNoRows) { + return ErrNotFound + } + if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) { + return ErrUnavailable + } + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) { + switch pgErr.Code { + case "23505": + return ErrConflict + case "23503", "23514", "22P02": + return ErrInvalid + case "57014", "55P03": + return ErrUnavailable + } + } + var netErr net.Error + if errors.As(err, &netErr) { + return ErrUnavailable + } + return err +} diff --git a/internal/store/postgres_test.go b/internal/store/postgres_test.go new file mode 100644 index 00000000..7ee018ba --- /dev/null +++ b/internal/store/postgres_test.go @@ -0,0 +1,131 @@ +package store + +import ( + "context" + "errors" + "os" + "sync" + "testing" + "time" + + "messenger/internal/migrate" +) + +func openIntegration(t *testing.T) *PG { + t.Helper() + raw := os.Getenv("DATABASE_URL") + if raw == "" { + t.Skip("DATABASE_URL is not set") + } + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + defer cancel() + pg, err := Open(ctx, raw, 10) + if err != nil { + t.Fatal(err) + } + t.Cleanup(pg.Close) + if err := migrate.Apply(ctx, pg.Pool()); err != nil { + t.Fatal(err) + } + return pg +} + +func TestIntegrationMigrationRerunKeepsRows(t *testing.T) { + pg := openIntegration(t) + ctx := context.Background() + name := "mig_" + newID()[:8] + if _, err := pg.CreateUser(ctx, name, "Миграция", "hash"); err != nil { + t.Fatal(err) + } + var before int + if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM users`).Scan(&before); err != nil { + t.Fatal(err) + } + if err := migrate.Apply(ctx, pg.Pool()); err != nil { + t.Fatal(err) + } + var after int + if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM users`).Scan(&after); err != nil { + t.Fatal(err) + } + if before != after { + t.Fatalf("migration rerun changed users %d -> %d", before, after) + } +} + +func TestIntegrationUsernameRace(t *testing.T) { + pg := openIntegration(t) + ctx := context.Background() + name := "race_" + newID()[:8] + const n = 32 + var wg sync.WaitGroup + wins := make(chan struct{}, n) + fails := make(chan error, n) + for i := 0; i < n; i++ { + wg.Add(1) + go func() { + defer wg.Done() + _, err := pg.CreateUser(ctx, name, "Гонка", "hash") + if err == nil { + wins <- struct{}{} + return + } + fails <- err + }() + } + wg.Wait() + close(wins) + close(fails) + got := 0 + for range wins { + got++ + } + if got != 1 { + t.Fatalf("winners = %d, want 1", got) + } + for err := range fails { + if !errors.Is(err, ErrConflict) { + t.Fatal(err) + } + } +} + +func TestIntegrationChatRollback(t *testing.T) { + pg := openIntegration(t) + ctx := context.Background() + u, err := pg.CreateUser(ctx, "rb_"+newID()[:8], "Откат", "hash") + if err != nil { + t.Fatal(err) + } + var before int + if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&before); err != nil { + t.Fatal(err) + } + _, err = pg.CreateChat(ctx, "не должен сохраниться", []string{u.ID, "99999999-9999-4999-8999-999999999999"}, u.ID) + if !errors.Is(err, ErrInvalid) { + t.Fatalf("want invalid, got %v", err) + } + var after int + if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&after); err != nil { + t.Fatal(err) + } + if before != after { + t.Fatalf("rolled-back chat stayed: %d -> %d", before, after) + } + var members int + if err := pg.Pool().QueryRow(ctx, `SELECT count(*) FROM chat_members WHERE user_id = $1`, u.ID).Scan(&members); err != nil { + t.Fatal(err) + } + if members != 0 { + t.Fatalf("rolled-back membership stayed: %d", members) + } +} + +func TestPostgresUnreachable(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) + defer cancel() + _, err := Open(ctx, "postgres://messenger:secret@127.0.0.1:1/messenger?sslmode=disable&connect_timeout=1", 1) + if err == nil { + t.Fatal("closed port was accepted") + } +} diff --git a/internal/store/store.go b/internal/store/store.go new file mode 100644 index 00000000..181ed1ce --- /dev/null +++ b/internal/store/store.go @@ -0,0 +1,326 @@ +package store + +import ( + "context" + "crypto/rand" + "encoding/hex" + "errors" + "sync" + "time" +) + +var ( + ErrConflict = errors.New("conflict") + ErrNotFound = errors.New("not found") + ErrInvalid = errors.New("invalid") + ErrBadCursor = errors.New("bad cursor") + ErrUnavailable = errors.New("unavailable") +) + +// User — публичная карточка. Хеш пароля в неё не входит. +type User struct { + ID string + Username string + DisplayName string + CreatedAt time.Time +} + +// Chat — неизменяемый состав участников. +type Chat struct { + ID string + Title string + MemberIDs []string + CreatedAt time.Time +} + +// Message — подтверждённое сообщение. Текст после записи не меняется. +type Message struct { + ID string + ChatID string + SenderID string + Text string + CreatedAt time.Time +} + +// Cursor — позиция keyset (created_at, id). Пустые поля означают первую страницу. +type Cursor struct { + ID string + At time.Time +} + +// Repository — пользователи, чаты и сообщения. Сессии сюда не входят. +type Repository interface { + Ping(ctx context.Context) error + CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) + User(ctx context.Context, id string) (User, error) + UserByUsername(ctx context.Context, username string) (User, string, error) + CreateChat(ctx context.Context, title string, memberIDs []string, caller string) (Chat, error) + ChatFor(ctx context.Context, chatID, userID string) (Chat, error) + ListChats(ctx context.Context, userID string, cur *Cursor, limit int) ([]Chat, bool, error) + AddMessage(ctx context.Context, chatID, senderID, text string) (Message, error) + ListMessages(ctx context.Context, chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error) +} + +type chatRec struct { + chat Chat + members map[string]struct{} +} + +// Memory сериализует записи мьютексом. Это двойник контракта для тестов без PostgreSQL. +type Memory struct { + mu sync.RWMutex + users map[string]User + byName map[string]string + hashes map[string]string + chats map[string]*chatRec + chatOrder []string + messages map[string][]Message + msgIndex map[string]map[string]int + last time.Time +} + +func New() *Memory { + return &Memory{ + users: make(map[string]User), + byName: make(map[string]string), + hashes: make(map[string]string), + chats: make(map[string]*chatRec), + messages: make(map[string][]Message), + msgIndex: make(map[string]map[string]int), + } +} + +func (s *Memory) Ping(ctx context.Context) error { + if err := ctx.Err(); err != nil { + return ErrUnavailable + } + return nil +} + +func (s *Memory) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) { + if err := ctx.Err(); err != nil { + return User{}, ErrUnavailable + } + s.mu.Lock() + defer s.mu.Unlock() + if _, ok := s.byName[username]; ok { + return User{}, ErrConflict + } + u := User{ + ID: newID(), + Username: username, + DisplayName: displayName, + CreatedAt: s.nextTimeLocked(), + } + s.users[u.ID] = u + s.byName[username] = u.ID + s.hashes[u.ID] = passwordHash + return u, nil +} + +func (s *Memory) User(ctx context.Context, id string) (User, error) { + if err := ctx.Err(); err != nil { + return User{}, ErrUnavailable + } + s.mu.RLock() + defer s.mu.RUnlock() + u, ok := s.users[id] + if !ok { + return User{}, ErrNotFound + } + return u, nil +} + +func (s *Memory) UserByUsername(ctx context.Context, username string) (User, string, error) { + if err := ctx.Err(); err != nil { + return User{}, "", ErrUnavailable + } + s.mu.RLock() + defer s.mu.RUnlock() + id, ok := s.byName[username] + if !ok { + return User{}, "", ErrNotFound + } + return s.users[id], s.hashes[id], nil +} + +func (s *Memory) CreateChat(ctx context.Context, title string, memberIDs []string, caller string) (Chat, error) { + if err := ctx.Err(); err != nil { + return Chat{}, ErrUnavailable + } + s.mu.Lock() + defer s.mu.Unlock() + seen := make(map[string]struct{}, len(memberIDs)) + for _, id := range memberIDs { + if _, dup := seen[id]; dup { + return Chat{}, ErrInvalid + } + seen[id] = struct{}{} + if _, ok := s.users[id]; !ok { + return Chat{}, ErrInvalid + } + } + if _, ok := seen[caller]; !ok { + return Chat{}, ErrInvalid + } + c := Chat{ + ID: newID(), + Title: title, + MemberIDs: append([]string(nil), memberIDs...), + CreatedAt: s.nextTimeLocked(), + } + s.chats[c.ID] = &chatRec{chat: c, members: seen} + s.chatOrder = append(s.chatOrder, c.ID) + s.messages[c.ID] = nil + s.msgIndex[c.ID] = make(map[string]int) + return c, nil +} + +func (s *Memory) ChatFor(ctx context.Context, chatID, userID string) (Chat, error) { + if err := ctx.Err(); err != nil { + return Chat{}, ErrUnavailable + } + s.mu.RLock() + defer s.mu.RUnlock() + rec, ok := s.chats[chatID] + if !ok { + return Chat{}, ErrNotFound + } + if _, member := rec.members[userID]; !member { + return Chat{}, ErrNotFound + } + return rec.chat.clone(), nil +} + +func (s *Memory) ListChats(ctx context.Context, userID string, cur *Cursor, limit int) ([]Chat, bool, error) { + if err := ctx.Err(); err != nil { + return nil, false, ErrUnavailable + } + s.mu.RLock() + defer s.mu.RUnlock() + filtered := make([]Chat, 0) + for _, id := range s.chatOrder { + rec := s.chats[id] + if _, ok := rec.members[userID]; ok { + filtered = append(filtered, rec.chat.clone()) + } + } + start, err := indexAfter(filtered, cur, func(c Chat) (string, time.Time) { + return c.ID, c.CreatedAt + }) + if err != nil { + return nil, false, err + } + end := start + limit + if end > len(filtered) { + end = len(filtered) + } + return append([]Chat(nil), filtered[start:end]...), end < len(filtered), nil +} + +func (s *Memory) AddMessage(ctx context.Context, chatID, senderID, text string) (Message, error) { + if err := ctx.Err(); err != nil { + return Message{}, ErrUnavailable + } + s.mu.Lock() + defer s.mu.Unlock() + rec, ok := s.chats[chatID] + if !ok { + return Message{}, ErrNotFound + } + if _, member := rec.members[senderID]; !member { + return Message{}, ErrNotFound + } + m := Message{ + ID: newID(), + ChatID: chatID, + SenderID: senderID, + Text: text, + CreatedAt: s.nextTimeLocked(), + } + idx := len(s.messages[chatID]) + s.messages[chatID] = append(s.messages[chatID], m) + s.msgIndex[chatID][m.ID] = idx + return m, nil +} + +func (s *Memory) ListMessages(ctx context.Context, chatID, userID string, cur *Cursor, limit int) ([]Message, bool, error) { + if err := ctx.Err(); err != nil { + return nil, false, ErrUnavailable + } + s.mu.RLock() + defer s.mu.RUnlock() + rec, ok := s.chats[chatID] + if !ok { + return nil, false, ErrNotFound + } + if _, member := rec.members[userID]; !member { + return nil, false, ErrNotFound + } + all := s.messages[chatID] + start := 0 + if cur != nil { + idx, ok := s.msgIndex[chatID][cur.ID] + if !ok || !all[idx].CreatedAt.Equal(cur.At) { + return nil, false, ErrBadCursor + } + start = idx + 1 + } + end := start + limit + if end > len(all) { + end = len(all) + } + out := append([]Message(nil), all[start:end]...) + return out, end < len(all), nil +} + +// nextTimeLocked выдаёт неубывающее время фиксации. +func (s *Memory) nextTimeLocked() time.Time { + now := time.Now().UTC().Truncate(time.Microsecond) + if !now.After(s.last) { + now = s.last.Add(time.Microsecond) + } + s.last = now + return now +} + +func indexAfter[T any](items []T, cur *Cursor, key func(T) (string, time.Time)) (int, error) { + if cur == nil { + return 0, nil + } + for i, item := range items { + id, at := key(item) + if id == cur.ID { + if !at.Equal(cur.At) { + return 0, ErrBadCursor + } + return i + 1, nil + } + } + return 0, ErrBadCursor +} + +func (c Chat) clone() Chat { + c.MemberIDs = append([]string(nil), c.MemberIDs...) + return c +} + +func newID() string { + var b [16]byte + if _, err := rand.Read(b[:]); err != nil { + panic("crypto/rand: " + err.Error()) + } + b[6] = (b[6] & 0x0f) | 0x40 + b[8] = (b[8] & 0x3f) | 0x80 + var buf [36]byte + hex.Encode(buf[0:8], b[0:4]) + buf[8] = '-' + hex.Encode(buf[9:13], b[4:6]) + buf[13] = '-' + hex.Encode(buf[14:18], b[6:8]) + buf[18] = '-' + hex.Encode(buf[19:23], b[8:10]) + buf[23] = '-' + hex.Encode(buf[24:36], b[10:16]) + return string(buf[:]) +} diff --git a/messenger/main.go b/messenger/main.go new file mode 100644 index 00000000..946bc76b --- /dev/null +++ b/messenger/main.go @@ -0,0 +1,138 @@ +package main + +import ( + "context" + "errors" + "io" + "log/slog" + "net" + "net/http" + "os" + "os/signal" + "strconv" + "syscall" + "time" + + "messenger/internal/api" + "messenger/internal/config" + "messenger/internal/migrate" + "messenger/internal/password" + "messenger/internal/session" + "messenger/internal/store" +) + +func main() { + if len(os.Args) > 1 && os.Args[1] == "healthcheck" { + os.Exit(runHealthcheck()) + } + + // Инициализация + cfg, err := config.Load() + if err != nil { + slog.Error("config", "err", err.Error()) + os.Exit(2) + } + log := slog.New(slog.NewJSONHandler(os.Stdout, nil)) + root, stop := context.WithTimeout(context.Background(), 20*time.Second) + pg, err := store.Open(root, cfg.DatabaseURL, cfg.DBMaxConns) + if err != nil { + stop() + log.Error("postgres", "err", "connect failed") + os.Exit(1) + } + defer pg.Close() + if err := migrate.Apply(root, pg.Pool()); err != nil { + stop() + log.Error("migrate", "err", "apply failed") + os.Exit(1) + } + sessions, err := session.OpenRedis(cfg.RedisURL) + if err != nil { + stop() + log.Error("redis", "err", "config failed") + os.Exit(1) + } + defer sessions.Close() + if err := sessions.Ping(root); err != nil { + stop() + log.Error("redis", "err", "ping failed") + os.Exit(1) + } + stop() + application := api.New(pg, sessions, password.Params{ + Time: cfg.Argon2Time, + Memory: cfg.Argon2Memory, + Threads: cfg.Argon2Threads, + }, cfg.SessionTTL, log) + // http сервер + srv := &http.Server{ + Addr: cfg.Addr(), + Handler: application, + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 15 * time.Second, + IdleTimeout: 60 * time.Second, + MaxHeaderBytes: 1 << 20, + } + + // Запуск сервера + errCh := make(chan error, 1) + go func() { + log.Info("listening", + "addr", cfg.Addr(), + "env", cfg.Env, + "shutdown_timeout_seconds", int(cfg.ShutdownTimeout/time.Second), + ) + err := srv.ListenAndServe() + if err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- err + } + close(errCh) + }() + + // Ожидание сигнала или ошибки + sig := make(chan os.Signal, 1) + signal.Notify(sig, syscall.SIGTERM, syscall.SIGINT) + select { + case err := <-errCh: + log.Error("server", "err", err.Error()) + os.Exit(1) + case <-sig: + } + + // Плавное завершение + application.BeginShutdown() + ctx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout) + defer cancel() + if err := srv.Shutdown(ctx); err != nil { + log.Error("shutdown timeout, closing listener", "err", err.Error()) + _ = srv.Close() + } + log.Info("shutdown complete") +} + +func runHealthcheck() int { + port := os.Getenv("APP_PORT") + if port == "" { + port = "8080" + } + n, err := strconv.Atoi(port) + if err != nil || n < 1 || n > 65535 { + return 1 + } + client := http.Client{Timeout: 2 * time.Second} + req, err := http.NewRequest(http.MethodGet, "http://"+net.JoinHostPort("127.0.0.1", port)+"/health/ready", nil) + if err != nil { + return 1 + } + resp, err := client.Do(req) + if err != nil { + return 1 + } + defer resp.Body.Close() + _, _ = io.Copy(io.Discard, resp.Body) + if resp.StatusCode != http.StatusOK { + return 1 + } + return 0 +} diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..637f0271 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,50 @@ +-- Пользователи, чаты, состав и сообщения. PostgreSQL — источник истины. +-- Сессии здесь не хранятся: их держит Redis с AOF. + +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, + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100), + CONSTRAINT users_password_hash_present CHECK (char_length(password_hash) > 0) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100) +); + +-- Список чатов пользователя идёт по (created_at, id). +CREATE INDEX chats_list_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + position integer NOT NULL, + PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_position_nonneg CHECK (position >= 0), + CONSTRAINT chat_members_position_unique UNIQUE (chat_id, position) +); + +-- Обратный поиск: чаты конкретного пользователя. +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id), + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000) +); + +-- Keyset-страница истории: WHERE chat_id = $1 AND (created_at, id) > cursor +-- ORDER BY created_at, id LIMIT n. Индекс покрывает фильтр и порядок, +-- поэтому страница не читает всю историю чата. +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); diff --git a/migrations/embed.go b/migrations/embed.go new file mode 100644 index 00000000..91460af0 --- /dev/null +++ b/migrations/embed.go @@ -0,0 +1,7 @@ +// хранит версионируемые SQL-файлы внутри бинарника. +package migrations + +import "embed" + +//go:embed *.sql +var FS embed.FS diff --git a/scripts/check_dependencies.sh b/scripts/check_dependencies.sh new file mode 100755 index 00000000..b2a6ec74 --- /dev/null +++ b/scripts/check_dependencies.sh @@ -0,0 +1,83 @@ +#!/bin/sh +# Отказ Redis и PostgreSQL: анонимный запрос остаётся 401, живой Bearer не становится доверенным. +set -eu +cd "$(dirname "$0")/.." +mkdir -p evidence +OUT=evidence/dependencies.txt +: > "$OUT" +log() { printf '%s\n' "$1" | tee -a "$OUT"; } + +code_of() { + # $1 name, $2 expected, $3 url, optional header in $4 + if [ "$#" -eq 4 ]; then + got=$(curl -sS -o /tmp/lab2_dep_body -w '%{http_code}' -H "$4" "$3") + else + got=$(curl -sS -o /tmp/lab2_dep_body -w '%{http_code}' "$3") + fi + log "$1 $got" + if [ "$got" != "$2" ]; then + log "FAIL $1 want $2" + exit 1 + fi +} + +wait_ready() { + i=0 + while [ "$i" -lt 90 ]; do + if curl -sf -o /dev/null http://127.0.0.1:8080/health/ready; then + return 0 + fi + i=$((i + 1)) + sleep 0.5 + done + log "FAIL ready did not return" + exit 1 +} + +trap 'rm -f /tmp/lab2_user.json /tmp/lab2_login.json /tmp/lab2_dep_body' EXIT +wait_ready +user="dep$(date +%s)" +pass="Dep-check-$(date +%s)-xxxx" +reg=$(curl -sS -o /tmp/lab2_user.json -w '%{http_code}' \ + -H 'Content-Type: application/json' \ + -d "{\"username\":\"$user\",\"display_name\":\"Зависимость\",\"password\":\"$pass\"}" \ + http://127.0.0.1:8080/api/v1/users) +if [ "$reg" != "201" ]; then + log "FAIL register $reg" + exit 1 +fi +basic=$(printf '%s' "$user:$pass" | base64 -w 0) +login=$(curl -sS -o /tmp/lab2_login.json -w '%{http_code}' \ + -X POST \ + -H "Authorization: Basic $basic" \ + http://127.0.0.1:8080/api/v1/auth/sessions) +if [ "$login" != "201" ]; then + log "FAIL login $login" + exit 1 +fi +token=$(python3 -c 'import json; print(json.load(open("/tmp/lab2_login.json"))["token"])') + +log "stop redis" +docker compose --env-file .env stop redis >> "$OUT" +code_of live_redis_down 200 http://127.0.0.1:8080/health/live +code_of ready_redis_down 503 http://127.0.0.1:8080/health/ready +code_of anon_redis_down 401 http://127.0.0.1:8080/api/v1/users/me +code_of bearer_redis_down 503 http://127.0.0.1:8080/api/v1/users/me "Authorization: Bearer $token" + +log "start redis" +docker compose --env-file .env start redis >> "$OUT" +wait_ready + +log "stop postgres" +docker compose --env-file .env stop postgres >> "$OUT" +code_of live_pg_down 200 http://127.0.0.1:8080/health/live +code_of ready_pg_down 503 http://127.0.0.1:8080/health/ready +code_of anon_pg_down 401 http://127.0.0.1:8080/api/v1/users/me +code_of bearer_pg_down 503 http://127.0.0.1:8080/api/v1/users/me "Authorization: Bearer $token" + +log "start postgres" +docker compose --env-file .env start postgres >> "$OUT" +wait_ready +code_of bearer_after 200 http://127.0.0.1:8080/api/v1/users/me "Authorization: Bearer $token" +log "PASS dependencies" +rm -f /tmp/lab2_user.json /tmp/lab2_login.json /tmp/lab2_login_hdr /tmp/lab2_dep_body diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..303ee2c1 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +# Перезапуск API и всех хранилищ с сохранением volumes. Данные не сидируются заново. +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart api postgres redis diff --git a/scripts/track2_experiment.sh b/scripts/track2_experiment.sh new file mode 100755 index 00000000..88cd5d07 --- /dev/null +++ b/scripts/track2_experiment.sh @@ -0,0 +1,211 @@ +#!/bin/sh +# Трек 5: два индекса, стоимость вставки, backup и сверка после restore. +# Секреты и токены не печатаются. Дамп остаётся в backups/ и не коммитится. +set -eu +set -o pipefail +cd "$(dirname "$0")/.." +mkdir -p evidence backups +OUT=evidence/track2_explain.txt +SUMMARY=evidence/track2_summary.txt +: > "$OUT" + +psql_db() { + db=$1 + shift + docker compose --env-file .env exec -T postgres \ + psql -U messenger -d "$db" -v ON_ERROR_STOP=1 "$@" +} + +echo "=== recreate bench ===" | tee -a "$OUT" +psql_db postgres <<'SQL' +SELECT pg_terminate_backend(pid) +FROM pg_stat_activity +WHERE datname IN ('messenger_bench', 'messenger_restore') + AND pid <> pg_backend_pid(); +DROP DATABASE IF EXISTS messenger_bench; +DROP DATABASE IF EXISTS messenger_restore; +CREATE DATABASE messenger_bench; +SQL + +docker compose --env-file .env exec -T postgres \ + psql -U messenger -d messenger_bench -v ON_ERROR_STOP=1 \ + < migrations/001_init.sql >> "$OUT" + +echo "=== seed uneven 100000 messages ===" | tee -a "$OUT" +psql_db messenger_bench <<'SQL' | tee -a "$OUT" +INSERT INTO users (id, username, display_name, password_hash, created_at) +VALUES ('aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', 'bench_user', 'Стенд', 'not-a-login-hash', '2026-01-01T00:00:00Z'); + +INSERT INTO chats (id, title, created_at) VALUES + ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1', 'big', '2026-01-01T00:00:00Z'), + ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb2', 'mid', '2026-01-01T00:00:01Z'), + ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb3', 'small', '2026-01-01T00:00:02Z'), + ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb4', 'write', '2026-01-01T00:00:03Z'); + +INSERT INTO chat_members (chat_id, user_id, position) +SELECT id, 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', 0 FROM chats; + +INSERT INTO chats (id, title, created_at) +SELECT gen_random_uuid(), 'tiny-' || g, timestamptz '2026-01-02' + g * interval '1 second' +FROM generate_series(1, 100) g; + +INSERT INTO chat_members (chat_id, user_id, position) +SELECT id, 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', 0 +FROM chats WHERE title LIKE 'tiny-%'; + +-- Времена всех чатов перемешаны. Иначе индекс только по created_at +-- читает сплошной кусок одного чата и не показывает цену фильтра chat_id. +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), + CASE + WHEN n % 100 < 80 THEN 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1'::uuid + WHEN n % 100 < 95 THEN 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb2'::uuid + WHEN n % 100 < 99 THEN 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb3'::uuid + ELSE (SELECT id FROM chats WHERE title = 'tiny-' || ((n / 100) % 100 + 1)) + END, + 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', + CASE + WHEN n % 100 < 80 THEN 'big-' || row_number() OVER (PARTITION BY n % 100 < 80, n % 100 < 95, n % 100 < 99 ORDER BY n) + WHEN n % 100 < 95 THEN 'mid-' || row_number() OVER (PARTITION BY n % 100 < 80, n % 100 < 95 ORDER BY n) + WHEN n % 100 < 99 THEN 'small-' || row_number() OVER (PARTITION BY n % 100 < 99 ORDER BY n) + ELSE 'tiny-' || row_number() OVER (PARTITION BY (n / 100) % 100 ORDER BY n) + END, + timestamptz '2026-01-01' + n * interval '1 microsecond' +FROM generate_series(1, 100000) AS n; + +SELECT title, count(*) AS messages +FROM chats c +JOIN messages m ON m.chat_id = c.id +GROUP BY title +ORDER BY messages DESC, title +LIMIT 8; + +SELECT count(*) AS messages_total FROM messages; +SHOW synchronous_commit; +SQL + +echo "=== cursor in the big chat ===" | tee -a "$OUT" +psql_db messenger_bench -At -F '|' -c "SELECT to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS.US'), id::text FROM messages WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1' ORDER BY created_at, id OFFSET 40000 LIMIT 1" > evidence/track2_cursor.txt +CUR_AT=$(cut -d'|' -f1 evidence/track2_cursor.txt) +CUR_ID=$(cut -d'|' -f2 evidence/track2_cursor.txt) +test -n "$CUR_AT" +test -n "$CUR_ID" + +run_explain() { + label=$1 + chat=$2 + echo "=== EXPLAIN $label chat=$chat ===" | tee -a "$OUT" + psql_db messenger_bench < (timestamptz '$CUR_AT UTC', '$CUR_ID'::uuid) +ORDER BY created_at, id +LIMIT 50; +SQL +} + +BIG=bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1 +SMALL=bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb3 +echo "=== no secondary index: seq scan of the whole table ===" | tee -a "$OUT" +psql_db messenger_bench -c 'DROP INDEX IF EXISTS messages_history_idx' | tee -a "$OUT" +run_explain "seq_scan" "$BIG" + +echo "=== index on (created_at, id) only ===" | tee -a "$OUT" +psql_db messenger_bench -c 'CREATE INDEX messages_time_idx ON messages (created_at, id)' | tee -a "$OUT" +run_explain "time_only_big" "$BIG" +run_explain "time_only_small" "$SMALL" + +echo "=== insert cost with time index ===" | tee -a "$OUT" +psql_db messenger_bench <<'SQL' 2>&1 | tee -a "$OUT" +DO $$ +DECLARE t0 timestamptz := clock_timestamp(); +BEGIN + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT gen_random_uuid(), 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb4', + 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', 'write-time-' || g, + timestamptz '2026-02-01' + g * interval '1 microsecond' + FROM generate_series(1, 5000) g; + RAISE NOTICE 'insert_5000_time_index_ms %', round(extract(epoch FROM clock_timestamp() - t0) * 1000, 3); +END $$; +DELETE FROM messages WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb4'; +DROP INDEX messages_time_idx; +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); +SQL + +run_explain "history_big" "$BIG" +run_explain "history_small" "$SMALL" + +echo "=== insert cost with history index ===" | tee -a "$OUT" +psql_db messenger_bench <<'SQL' 2>&1 | tee -a "$OUT" +DO $$ +DECLARE t0 timestamptz := clock_timestamp(); +BEGIN + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT gen_random_uuid(), 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb4', + 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', 'write-hist-' || g, + timestamptz '2026-02-02' + g * interval '1 microsecond' + FROM generate_series(1, 5000) g; + RAISE NOTICE 'insert_5000_history_index_ms %', round(extract(epoch FROM clock_timestamp() - t0) * 1000, 3); +END $$; +DELETE FROM messages WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb4'; +SQL + +echo "=== snapshot before dump ===" | tee -a "$OUT" +psql_db messenger_bench -At <<'SQL' > evidence/track2_before.txt +SELECT kind, value FROM ( + SELECT 'messages' AS kind, count(*)::text AS value FROM messages + UNION ALL SELECT 'chats', count(*)::text FROM chats + UNION ALL SELECT 'users', count(*)::text FROM users + UNION ALL SELECT 'big-1', text FROM messages WHERE text = 'big-1' + UNION ALL SELECT 'big-80000', text FROM messages WHERE text = 'big-80000' + UNION ALL SELECT 'mid-15000', text FROM messages WHERE text = 'mid-15000' + UNION ALL SELECT 'tiny-sample', min(m.text) + FROM messages m JOIN chats c ON c.id = m.chat_id WHERE c.title LIKE 'tiny-%' +) s ORDER BY kind; +SQL + +echo "=== dump and restore ===" | tee -a "$OUT" +DUMP_START=$(date +%s%N) +docker compose --env-file .env exec -T postgres \ + pg_dump -U messenger -Fc messenger_bench > backups/track2.dump +DUMP_MS=$(( ($(date +%s%N) - DUMP_START) / 1000000 )) + +psql_db postgres -c 'CREATE DATABASE messenger_restore' >> "$OUT" +docker compose --env-file .env cp backups/track2.dump postgres:/tmp/track2.dump +RESTORE_START=$(date +%s%N) +docker compose --env-file .env exec -T postgres \ + pg_restore -U messenger -d messenger_restore --exit-on-error /tmp/track2.dump +RESTORE_MS=$(( ($(date +%s%N) - RESTORE_START) / 1000000 )) +docker compose --env-file .env exec -T postgres rm -f /tmp/track2.dump + +psql_db messenger_restore -At <<'SQL' > evidence/track2_after.txt +SELECT kind, value FROM ( + SELECT 'messages' AS kind, count(*)::text AS value FROM messages + UNION ALL SELECT 'chats', count(*)::text FROM chats + UNION ALL SELECT 'users', count(*)::text FROM users + UNION ALL SELECT 'big-1', text FROM messages WHERE text = 'big-1' + UNION ALL SELECT 'big-80000', text FROM messages WHERE text = 'big-80000' + UNION ALL SELECT 'mid-15000', text FROM messages WHERE text = 'mid-15000' + UNION ALL SELECT 'tiny-sample', min(m.text) + FROM messages m JOIN chats c ON c.id = m.chat_id WHERE c.title LIKE 'tiny-%' +) s ORDER BY kind; +SQL + +if ! cmp -s evidence/track2_before.txt evidence/track2_after.txt; then + echo "RESTORE MISMATCH" | tee -a "$OUT" + diff -u evidence/track2_before.txt evidence/track2_after.txt | tee -a "$OUT" + exit 1 +fi + +{ + echo "messages_before=$(grep '^messages' evidence/track2_before.txt)" + echo "dump_ms=$DUMP_MS" + echo "restore_ms=$RESTORE_MS" + echo "compare=match" + echo "synchronous_commit=on" + echo "hypothesis=history index reads one chat range; time-only index filters chat_id after walking created_at" +} | tee "$SUMMARY" +echo "PASS track2" | tee -a "$OUT"