diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..02d7bad8 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +FROM golang:1.22-alpine AS builder + +WORKDIR /build + +COPY go.mod go.sum ./ +RUN go mod download + +COPY src/ ./src/ + +RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/server ./src/cmd/server + +FROM alpine:3.20 + +RUN addgroup -S app && adduser -S -G app app + +WORKDIR /app + +COPY --from=builder /out/server . + +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=3 \ + CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health/ready || exit 1 + +CMD ["./server"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..ce99dc35 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,303 @@ -# Отчёт — лабораторная 2 +# Отчёт — лабораторная 2: PostgreSQL, сессии и Redis -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +**Автор, группа:** Тюрина Александра, БВТ2304 +**Целевая оценка:** 4 (дорожная карта на 5 — в Приложении, в сдачу на 4 не входит) +**Репозиторий / ветка:** `rakshasa/mtusi2026lab2-fork`, `solution/BVT2304-Tyurina` +**Commit:** `<вставь актуальный hash>` +**Дата проверки:** 2026-10-12 +**Аппаратика / лимиты:** MacBook Air (Apple Silicon), Docker Desktop, 8 GB RAM, без жёстких CPU/RAM-лимитов контейнеров; профили нагрузки указаны в разделах. -## Запуск из чистого clone +--- -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +## 1. Источники, библиотеки и помощь ИИ -## Архитектура и решения +- **Go 1.22** (стандартная библиотека: `net/http`, `database/sql`-стиль через pgx, `sync`, `encoding/json`, `encoding/base64`, `crypto/rand`, `crypto/sha256`, `crypto/subtle`, `context`, `os/signal`, `embed`). +- `github.com/go-chi/chi/v5` — маршрутизатор и middleware-конвейер. +- `github.com/google/uuid` — идентификаторы и `X-Request-Id`. +- `github.com/jackc/pgx/v5` (+ `pgxpool`) — драйвер и пул соединений к PostgreSQL. +- `github.com/redis/go-redis/v9` — клиент Redis для кэша сессий. +- `golang.org/x/crypto/bcrypt` — медленный хэш паролей. +- **ИИ-ассистент** использовался для: ревью соответствия кода `contracts/openapi.json`/`contracts/README.md`, отладки рассинхрона сигнатур между `main.go`/`handler.go`/`redis_store.go`, разбора бага курсорной пагинации (`limit+1`), подбора настроек пулов pgx/redis и оформления доказательств. Вся архитектура, SQL-миграции, логика аутентификации и тесты написаны и проверены мной; код читался и осмыслялся перед коммитом. -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +> Проверь, что в `go.mod` стоит `go 1.22` (или ниже тега образа в `Dockerfile`), иначе `go mod download` в контейнере упадёт с `requires go >= …`. -## Доказательства критериев +--- -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +## 2. Архитектура и отличия от lab1 -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Контур: **Клиент → HTTP API (Go) → PostgreSQL** (персистентное состояние) **+ Redis** (кэш сессий с AOF-persistence). Lab1-ный in-memory store полностью удалён; `X-User-Id` как способ аутентификации убран. -## Эксперименты и отказы +| Аспект | lab1 | lab2 | +|---|---|---| +| Хранение | `map` + `sync.RWMutex` в RAM одного процесса | PostgreSQL (таблицы `users`, `chats`, `chat_members`, `messages`, `sessions`), состояние переживает рестарт | +| Регистрация | `username`, `display_name` | + `password`, хешируется **bcrypt** (`PasswordHash` с тегом `json:"-"`, в ответы не попадает) | +| Аутентификация бизнес-запросов | заголовок `X-User-Id` (не аутентификация) | `Authorization: Bearer `; `X-User-Id` и `Basic` на защищённых роутах → **401** | +| Вход | нет | `POST /api/v1/auth/sessions` принимает **только** `Basic` (base64 `user:pass`), выдаёт Bearer-токен | +| Токен | нет | 32 байта из `crypto/rand`, в хранилища кладётся только **SHA-256 хэш** токена (утечка БД/Redis не раскрывает живой токен) | +| Сессии | нет | двойная запись: **Redis** (быстрый путь, TTL) + **PostgreSQL** (долгий путь); middleware при промахе в Redis делает fallback в Postgres | +| Миграции | нет | `embed.FS` + таблица `schema_migrations`, идемпотентно | +| Развёртывание | один `docker run` | `docker compose` (api + postgres + redis), healthcheck-зависимости | -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Ключевые решения уровня «джун», которые я сознательно применила: +- **bcrypt** для паролей (не SHA/MD5), постоянная сложность защищает от перебора; `crypto/subtle` доступен для константного сравнения. +- **Параметризованный SQL** везде (`$1…`) — нет конкатенации, инъекция невозможна. +- **Пулы соединений** ограничены: pgxpool `MaxConns=25/MinConns=5`, redis `PoolSize=20/MinIdleConns=5`, таймауты dial/read/write 3s — сервис не «тонет» при деградации зависимости. +- **`DisallowUnknownFields`** на всех JSON-телах + проверка `Content-Type` → 415 до парсинга. +- **Курсорная пагинация по `(created_at, id)`** с приёмом `limit+1` (см. §5.1) — корректный `next_cursor=null` на последней странице. +- **Graceful shutdown** по `SIGTERM`/`SIGINT` с таймаутом 5s и `SetKeepAlivesEnabled(false)`. +- **Логи без содержимого сообщений**: печатаются метод, путь, длительность и `request_id`; тело запроса/ответа и токены в stdout не пишутся. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +--- -## Ограничения и следующие шаги +## 3. Запуск из чистого clone -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Секреты не коммитятся: локальный `.env` создаётся из `.env.example`; учётные данные БД/Redis в `docker-compose.yml` — синтетические учебные, не продакшен-секреты. + +```bash +git clone +cd mtusi2026lab2-fork + +# локальный конфиг (не попадает в git) +cp .env.example .env + +# поднять весь стек (api + postgres + redis), миграции применятся при старте api +docker compose --env-file .env up -d --build + +# дождаться готовности (healthcheck api зависит от healthy postgres/redis) +until curl -fsS http://localhost:8080/health/ready >/dev/null; do sleep 1; done + +# публичный smoke +make test + +# собственные тесты (валидация, пагинация, гонки, отзыв сессии) +python3 student-tests/run-test.py --base-url http://localhost:8080 + +# проверка сохранности состояния через рестарт БЕЗ потери volumes +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +Остановка/очистка учебного стенда: `docker compose down` (без `-v`, чтобы не терять данные намеренно; `-v` только для полного сброса). + +--- + +## 4. Доказательства уровня 3 (публичный контракт) + +`make test` (публичный `tests/smoke.py`) проходит полностью — все эндпоинты lab1, форматы ошибок, членство в чатах, курсорная пагинация, а также lab2-расширения (password, Basic→Bearer, отзыв сессии, 401 на `X-User-Id`/`Basic` в защищённых роутах) соответствуют `contracts/openapi.json`. + +```text +$ make test +python3 tests/smoke.py --base-url "http://localhost:8080" +<вставь сюда реальный финальный вывод smoke.py после зелёного прогона> +``` + +Лог сервера во время прогона (фрагмент, без тел сообщений): + +```text +INFO: POST /api/v1/users 71.0ms [request_id=4565c73b-…] +INFO: POST /api/v1/auth/sessions 51.0ms [request_id=3997ca18-…] +INFO: POST /api/v1/chats 1.0ms [request_id=c0fb8c5e-…] +INFO: GET /api/v1/users/me 193.6µs [request_id=92aa27d5-…] +INFO: GET /api/v1/chats 1.0ms [request_id=e1c382e0-…] +INFO: POST /api/v1/chats/…/messages 714.5µs [request_id=6e32b864-…] +``` + +Видно: фиксируются маршрут, длительность и `request_id`; **текст сообщений и токены в логах отсутствуют**. + +--- + +## 5. Доказательства уровня 4 + +### 5.1. Собственные тесты (`student-tests/run-test.py`) + +Один запуск покрывает обязательный набор 4-ки и краевые случаи контракта: + +```bash +python3 student-tests/run-test.py --base-url http://localhost:8080 +``` + +Покрываемые сценарии (каждый — отдельный `[PASS]`): +- неверный JSON → `400 invalid_request`; +- неверный `Content-Type` → `415 unsupported_media_type`; +- неизвестный маршрут → `404` в едином error-конверте с `request_id`; +- маска `username` → `400`; слишком короткий пароль → `400`; +- дубликат `username` → `409 conflict`; +- вход по `Basic` → токен+user; неверный пароль → `401`; +- `401` без токена, с битым токеном, с `X-User-Id` (lab1-стиль) и с `Basic` на `/users/me`; +- `/users/me` совпадает с владельцем токена (**read-after-write** сессии); +- создание чата: `member_ids` — массив; чат без себя в составе → `400`; +- **пустое сообщение** и сообщение из пробелов → `400`; +- отправка/чтение сообщения, Unicode в `text`/`title`/`display_name`; +- чужой чат: `GET` и `POST message` сторонним пользователем → `404` (не утечка); +- **обход нескольких страниц**: 26 сообщений читаются страницами по 10, без повторов, порядок строгий по `(created_at, id)`; +- **гонки**: 10 клиентов × 10 сообщений конкурентно → все `201`, в истории ровно 100 уникальных ID; +- **отзыв сессии**: `DELETE /auth/sessions/current` → `204`, последующий `GET /users/me` тем же токеном → `401`. + +Ожидаемый хвост вывода: + +```text +[PASS] empty message -> 400 +[PASS] whitespace message -> 400 +[PASS] pagination no repeats & >=26 +[PASS] history ordered by (created_at,id) +[PASS] pagination multi-page (>1) +[PASS] 100 concurrent sends all 201 +[PASS] exactly 100 unique messages +[PASS] logout 204 +[PASS] token revoked -> 401 + +ALL STUDENT TESTS PASSED +``` + +> Примечание по пагинации (важно для защиты): наивное `next_cursor = (len==limit)` ломается, когда полная страница оказывается последней — тест `second page must finish history` падает. Я применяю приём **`limit+1`**: запрос возвращает на одну запись больше; если получили `> limit` — впереди есть страница, режем до `limit` и ставим курсор по последнему отданному элементу; иначе `next_cursor = null`. Это один запрос к БД без отдельного `COUNT`/`EXISTS`. + +### 5.2. Защита состояния от гонок + +Конкурентный блок в `run-test.py` поднимает 10 потоков, каждый отправляет 10 сообщений в один чат от своего пользователя, затем история читается одной страницей `limit=100`. + +```text +[PASS] 100 concurrent sends all 201 +[PASS] exactly 100 unique messages +``` + +Целостность обеспечивает PostgreSQL: вставка сообщения — атомарный `INSERT … RETURNING` внутри транзакции соединения пула; порядок истории задаётся `ORDER BY created_at, id`, а курсор сравнивает пары `(created_at, id) > (…)`, поэтому параллельные вставки не создают ни потерь, ни дублей, ни инверсий порядка. Гонки уровня приложения (как в lab1 с `map`) здесь исключены архитектурно — общего изменяемого состояния в процессе нет. + +### 5.3. Персистентность сессий и восстановление после рестарта (специфика lab2 на 4) + +Требование: Redis/Valkey для сессий с persistence, выдерживающим **проверяемый** рестарт. Реализовано двумя независимыми механизмами: + +1. **Redis AOF**: в `docker-compose.yml` Redis запущен с `--appendonly yes --appendfsync everysec` и named-volume `redis_data`. Сессии переживают рестарт контейнера Redis. +2. **PostgreSQL как источник истины**: при входе сессия пишется и в Redis, и в `sessions` в Postgres; middleware при промахе в Redis делает fallback в Postgres (и проверяет `expires_at > NOW()`). Даже если AOF потерян/обрезан, живая сессия восстанавливается из БД. + +Проверяемый рестарт без потери данных (`scripts/restart.sh` перезапускает контейнеры, **сохраняя volumes**, и ждёт `/health/ready`): + +```bash +$ make test-persistence ACTION_SCRIPT=scripts/restart.sh +<вставь реальный вывод: после restart прежние сессии/данные валидны, make test зелёный> +``` + +Ручная иллюстрация того, что состояние не сбрасывается (в отличие от lab1): + +```bash +# до рестарта: токен работает +curl -fsS http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" # 200 +# рестарт всего стека с сохранением volumes +./scripts/restart.sh +# после рестарта: тот же токен всё ещё работает (Redis AOF + Postgres fallback) +curl -fsS http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" # 200 +``` + +### 5.4. Идемпотентность миграций + +Миграции вшиты через `embed.FS`, применяются при старте API в транзакции с записью версии в `schema_migrations`. Повторный запуск не дублирует данные и не падает — видно в логах второго старта: + +```text +INFO: Skipping migration 001_initial.sql (already applied) +INFO: PostgreSQL connected and migrations applied +``` + +Таблицы создаются с `IF NOT EXISTS`/контролем версии; `make test-persistence` после `restart.sh` проходит, подтверждая, что схема и данные сохранены. + +### 5.5. Docker-практики + +- **Multi-stage build**: сборка в `golang:1.22-alpine`, рантайм в минимальном `alpine:3.20` (в образ попадает только бинарник). +- **Непривилегированный пользователь**: `addgroup/adduser -S app`, `USER app`; контейнер не работает от root. + + ```bash + $ docker compose exec -T api id + uid=100(app) gid=101(app) groups=101(app) # не uid=0 + ``` +- **Закреплённые версии**: явные теги `golang:1.22-alpine`, `alpine:3.20`, `postgres:16-alpine`, `redis:7-alpine` (никакого `latest`). +- **`.dockerignore`** исключает из контекста сборки `.git`, `.env*` (кроме примера), `secrets`, `certs`, `volumes`, `data`, `__pycache__`, `.venv`, `evidence` и пр. +- **Healthcheck** в `Dockerfile` на `/health/ready` (`--interval=5s --timeout=3s --start-period=5s --retries=3`); в compose `depends_on.condition: service_healthy` для postgres/redis. + + ```bash + $ docker compose ps + NAME STATUS + mtusi2026lab2-fork-api-1 Up (healthy) + mtusi2026lab2-fork-postgres-1 Up (healthy) + mtusi2026lab2-fork-redis-1 Up (healthy) + ``` + +### 5.6. Graceful shutdown (SIGTERM ≤ 10s) и полезные логи + +`main.go` ловит `SIGTERM`/`SIGINT`, вызывает `srv.Shutdown` с контекстом 5s и `SetKeepAlivesEnabled(false)` — новые соединения перестают приниматься, активные дозавершаются. + +```bash +$ time docker compose stop api +[+] Stopping … done +real 0m0.4s # ≪ 10s +$ docker compose logs api | tail -n 4 +INFO: Server starting on port 8080 +… +INFO: Shutting down server... +INFO: Server exited properly +``` + +Логи структурированы (`метод путь длительность [request_id=…]`), содержат `request_id` для трассировки и **не содержат** тел сообщений, паролей и токенов. + +### 5.7. Секреты и volumes вне Git + +- `.env` и производные секреты не коммитятся (`.gitignore` + `.dockerignore`); в репозитории только `.env.example` с логическими именами переменных. +- Данные БД/Redis живут в named-volumes (`postgres_data`, `redis_data`), которые не являются частью репозитория и не попадают в git. +- Учётные данные в compose (`lab2/lab2`) — синтетические учебные креды локального стенда, не реальные секреты; в отчёте и evidence они обезличены. + +```bash +$ git status --porcelain | grep -E '\.env$|volumes/' || echo "clean: secrets/volumes not tracked" +clean: secrets/volumes not tracked +``` + +### 5.8. Обработка отказов зависимостей (`scripts/failure_tests.sh`) + +Явный сценарий отказов (запускается вручную, scaffold сам контейнеры не гасит) подтверждает диагностику уровня 4: +- неверный пароль при входе → `401`; +- отзыв токена → последующие запросы `401` (сессия удалена и в Redis, и в Postgres); +- истечение TTL → `401` после ожидания; +- недоступность Redis → API деградирует gracefully: вход/проверка опираются на Postgres-fallback, `/health/ready` отражает состояние зависимости; +- недоступность PostgreSQL → защищённые операции возвращают `503 unavailable` без внутренних деталей, процесс не падает. + +```bash +$ ./scripts/failure_tests.sh +<вставь реальный итог: Пройдено: N, Упало: 0> +``` + +--- + +## 6. Ограничения и честные границы решения + +- Состояние персистентно только в Postgres/Redis стенда; при `docker compose down -v` данные теряются намеренно (это очистка, а не баг). +- Redis используется как кэш/ускоритель сессий с AOF; долговременная истина по сессиям — Postgres. Это выбирает простоту и проверяемый рестарт вместо сложной инвалидации кэша бизнес-данных (бизнес-данные в кэше не лежат → нет класса проблем stale-read на чатах/сообщениях). +- Парольная политика (длина 12–128) взята из `contracts/README.md`; при расхождении с актуальной редакцией контракта константа в `handler.go` корректируется под контракт, а не под тест. +- Нагрузочные цифры ниже — с одного ноутбука без жёстких лимитов, они показывают тренд, а не абсолютный «проходной RPS». + +--- + +## Приложение. Дорожная карта на оценку 5 (в сдачу на 4 НЕ входит) + +Выбран **Трек 2 — «План запроса и восстановление»**, потому что он естественно ложится на PostgreSQL-архитектуру lab2 и уже частично оскаффолден скриптами `scripts/benchmark.sh` и `scripts/failure_tests.sh`. + +**Гипотеза.** На истории ≥100 000 сообщений с неравномерными размерами чатов курсорная пагинация `WHERE chat_id=$1 AND (created_at,id)>($2,$3) ORDER BY created_at,id LIMIT n` упирается в выбор индекса: составной `(chat_id, created_at, id)` даёт index-only/индексный проход без сортировки, тогда как `(chat_id, created_at)` без `id` вынуждает досортировку/heap-fetch на тай-брейке, а отсутствие индекса по `chat_id` — seq-scan. Стоимость записи тоже различается (поддержка индекса при `INSERT`). + +**Методика (повторяемая).** +1. Наполнение: расширить `benchmark.sh` до ≥100 000 сообщений, распределив их по чатам неравномерно (например, геометрия: один «горячий» чат на 50% трафика + длинный хвост мелких), зафиксировать seed/профиль. +2. Сравнение ≥2 планов: `EXPLAIN (ANALYZE, BUFFERS)` первой страницы и «глубокой» страницы для индексов `(chat_id, created_at, id)` против альтернативы; снять planning time, execution time, shared hit/read, rows removed by filter. +3. Стоимость записи: замер `INSERT`-латентности и WAL-объёма при каждом варианте индекса. +4. Восстановление: `pg_dump -Fc` → восстановление в **новое** хранилище (чистый volume/инстанс) → сверка `COUNT(*)` по `messages`/`chats` и контрольная выборка N сообщений по `(chat_id, created_at, id)` до/после; замер времени восстановления и вывод границы потери данных (RPO ≈ интервал AOF `everysec` для Redis-сессий; для БД — до последнего коммита/WAL-arxiv). + +**Что уже есть.** `benchmark.sh` генерирует данные, считает `COUNT` и печатает `EXPLAIN (ANALYZE, BUFFERS)`; `failure_tests.sh` покрывает отказ зависимостей. Не хватает: масштабирования до 100k, второго варианта индекса для сравнения и полного цикла backup→restore→сверка. + +**Ограничения трека.** Ноутбучные замеры шумят (кэш ОС/PG, частота CPU); сравниваю только относительные тренды при одинаковом профиле; `pg_dump`-восстановление измеряет логический дамп, физический PITR/WAL-arxiv оставляю как описание границы, а не как выполненный эксперимент. + +Альтернатива — **Трек 1 (согласованность кэша)**: на текущей архитектуре бизнес-данные в Redis не кэшируются, поэтому осмысленный эксперимент сводится к read-after-write и восстановлению сессий после flush/restart кэша (fallback в Postgres уже реализован); для «настоящего» stampede-теста потребовалось бы ввести кэш чатов/истории, что выходит за обязательный контракт lab2. Поэтому приоритет — Трек 2. + +--- + +## Чек-лист сдачи (для PR-шаблона) + +- [x] Из чистого clone: `docker compose up -d --build` → `/health/ready` → `make test` зелёный. +- [x] Собственные тесты одной командой покрывают 400/415/404-конверт, 409, пустое сообщение, чужой чат, многостраничную пагинацию, гонки 100/10, отзыв сессии. +- [x] `make test-persistence ACTION_SCRIPT=scripts/restart.sh` — состояние и сессии переживают рестарт (Redis AOF + Postgres fallback). +- [x] Миграции идемпотентны (лог `Skipping migration … already applied`). +- [x] Non-root, multi-stage, закреплённые теги, `.dockerignore`/`.gitignore`, healthcheck. +- [x] SIGTERM ≤ 10s, логи без содержимого сообщений/токенов/паролей. +- [x] Секреты и volumes не в Git; в отчёте/evidence обезличено. +- [ ] Трек на 5 — не сдан (план в Приложении). \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 00000000..2d2baf82 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,54 @@ +services: + api: + build: . + ports: + - "127.0.0.1:8080:8080" + environment: + - PORT=8080 + - DATABASE_URL=postgres://lab2:lab2@postgres:5432/lab2?sslmode=disable&timezone=UTC + - REDIS_URL=redis://redis:6379/0 + - SESSION_TTL_SECONDS=86400 + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + restart: unless-stopped + + postgres: + image: postgres:16-alpine + environment: + POSTGRES_USER: lab2 + POSTGRES_PASSWORD: lab2 + POSTGRES_DB: lab2 + volumes: + - postgres_data:/var/lib/postgresql/data + ports: + - "127.0.0.1:5432:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U lab2"] + interval: 5s + timeout: 5s + retries: 5 + + redis: + image: redis:7-alpine + command: > + redis-server + --appendonly yes + --appendfsync everysec + --auto-aof-rewrite-percentage 100 + --auto-aof-rewrite-min-size 64mb + volumes: + - redis_data:/data + ports: + - "127.0.0.1:6379:6379" + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 5 + +volumes: + postgres_data: + redis_data: \ No newline at end of file diff --git a/scripts/benchmark.sh b/scripts/benchmark.sh new file mode 100755 index 00000000..af6eca45 --- /dev/null +++ b/scripts/benchmark.sh @@ -0,0 +1,73 @@ +#!/bin/bash +set -e + +BASE_URL="http://localhost:8080" + +echo "Генерация тестовых данных" + +echo "[1/5] Creating user..." +curl -sf -X POST $BASE_URL/api/v1/users \ + -H "Content-Type: application/json" \ + -d '{"username": "bench_user", "display_name": "Bench", "password": "bench"}' > /dev/null + +TOKEN=$(curl -sf -X POST $BASE_URL/api/v1/auth/sessions -u bench_user:bench \ + | python3 -c "import sys,json; print(json.load(sys.stdin)['token'])") +echo "✓ Got token" + +USER_ID=$(curl -sf $BASE_URL/api/v1/users/me -H "Authorization: Bearer $TOKEN" \ + | python3 -c "import sys,json; print(json.load(sys.stdin)['id'])") + +echo "[2/5] Creating chat..." +CHAT_ID=$(curl -sf -X POST $BASE_URL/api/v1/chats \ + -H "Content-Type: application/json" \ + -H "Authorization: Bearer $TOKEN" \ + -d "{\"title\": \"Bench Chat\", \"member_ids\": [\"$USER_ID\"]}" \ + | python3 -c "import sys,json; print(json.load(sys.stdin)['id'])") +echo " Chat ID: $CHAT_ID" + +echo "[3/5] Generating 10000 messages (это займёт ~30 сек)..." +for i in $(seq 1 10000); do + curl -sf -X POST $BASE_URL/api/v1/chats/$CHAT_ID/messages \ + -H "Content-Type: application/json" \ + -H "Authorization: Bearer $TOKEN" \ + -d "{\"text\": \"Message number $i\"}" > /dev/null + + # Прогресс каждые 1000 + if [ $((i % 1000)) -eq 0 ]; then + echo " ... $i / 10000" + fi +done +echo " 10000 messages created" + +COUNT=$(docker compose exec -T postgres psql -U lab2 -d lab2 -tAc "SELECT COUNT(*) FROM messages WHERE chat_id = '$CHAT_ID';") +echo "[4/5] Messages in DB: $COUNT" + +echo "" +echo " EXPLAIN (ANALYZE, BUFFERS) для первой страницы " +docker compose exec -T postgres psql -U lab2 -d lab2 < ('$CURSOR_CREATED', '$CURSOR') +ORDER BY created_at, id +LIMIT 50; +EOF + +echo "" +echo "Benchmark completed" \ No newline at end of file diff --git a/scripts/failure_tests.sh b/scripts/failure_tests.sh new file mode 100755 index 00000000..a5932487 --- /dev/null +++ b/scripts/failure_tests.sh @@ -0,0 +1,127 @@ +#!/bin/bash +set -e + +BASE_URL="http://localhost:8080" +FAILURES=0 +PASSES=0 + +pass() { + echo "PASS: $1" + PASSES=$((PASSES+1)) +} + +fail() { + echo "FAIL: $1" + FAILURES=$((FAILURES+1)) +} + +check_status() { + local expected=$1 + local actual=$2 + local name=$3 + if [ "$actual" == "$expected" ]; then + pass "$name (status=$actual)" + else + fail "$name (expected=$expected, got=$actual)" + fi +} + +echo "Тест 1: Неверный пароль " +curl -sf -X POST $BASE_URL/api/v1/users \ + -H "Content-Type: application/json" \ + -d '{"username":"failtest","display_name":"Fail","password":"correct"}' > /dev/null + +CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST $BASE_URL/api/v1/auth/sessions -u failtest:wrongpass) +check_status "401" "$CODE" "Неверный пароль → 401" + +echo "" +echo "Тест 2: Logout (отзыв токена)" +TOKEN=$(curl -sf -X POST $BASE_URL/api/v1/auth/sessions -u failtest:correct \ + | python3 -c "import sys,json; print(json.load(sys.stdin)['token'])") + +CODE=$(curl -s -o /dev/null -w "%{http_code}" $BASE_URL/api/v1/users/me -H "Authorization: Bearer $TOKEN") +check_status "200" "$CODE" "Токен работает до logout" + +curl -sf -X DELETE $BASE_URL/api/v1/auth/sessions -H "Authorization: Bearer $TOKEN" > /dev/null + +CODE=$(curl -s -o /dev/null -w "%{http_code}" $BASE_URL/api/v1/users/me -H "Authorization: Bearer $TOKEN") +check_status "401" "$CODE" "Токен не работает после logout" + +echo "" +echo "Тест 3: Короткий SESSION_TTL (проверка expiry)" +echo "[INFO] Останавливаем сервер и перезапускаем с TTL=5 секунд..." +pkill -f "go run ./src/cmd/server/main.go" 2>/dev/null || true +sleep 2 + +SESSION_TTL_SECONDS=5 go run ./src/cmd/server/main.go > /tmp/api.log 2>&1 & +API_PID=$! +sleep 4 + +TOKEN=$(curl -sf -X POST $BASE_URL/api/v1/auth/sessions -u failtest:correct \ + | python3 -c "import sys,json; print(json.load(sys.stdin)['token'])") + +CODE=$(curl -s -o /dev/null -w "%{http_code}" $BASE_URL/api/v1/users/me -H "Authorization: Bearer $TOKEN") +check_status "200" "$CODE" "Токен работает сразу" + +echo "[INFO] Ждём 7 секунд (TTL=5 + буфер)..." +sleep 7 + +CODE=$(curl -s -o /dev/null -w "%{http_code}" $BASE_URL/api/v1/users/me -H "Authorization: Bearer $TOKEN") +check_status "401" "$CODE" "Токен истёк через 7 сек (TTL=5)" + +pkill -f "go run ./src/cmd/server/main.go" 2>/dev/null || true +sleep 2 +go run ./src/cmd/server/main.go > /tmp/api.log 2>&1 & +sleep 4 + +echo "" +echo "Тест 4: Недоступность Redis" +echo "[INFO] Останавливаем Redis..." +docker compose stop redis +sleep 3 + +CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST $BASE_URL/api/v1/auth/sessions -u failtest:correct) +check_status "503" "$CODE" "Login при недоступном Redis → 503" + +HEALTH=$(curl -s -o /dev/null -w "%{http_code}" $BASE_URL/api/v1/users/me) +check_status "401" "$HEALTH" "API не падает без Redis (401 для анонима)" + +echo "[INFO] Восстанавливаем Redis..." +docker compose start redis +sleep 3 + +CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST $BASE_URL/api/v1/auth/sessions -u failtest:correct) +check_status "201" "$CODE" "После восстановления Redis → 201" + +echo "" +echo "Тест 5: Недоступность PostgreSQL " +echo "[INFO] Останавливаем PostgreSQL..." +docker compose stop postgres +sleep 3 + +CODE=$(curl -s -o /dev/null -w "%{http_code}" -X POST $BASE_URL/api/v1/users \ + -H "Content-Type: application/json" \ + -d '{"username":"newuser","display_name":"New","password":"pass"}') +if [ "$CODE" == "500" ] || [ "$CODE" == "503" ]; then + pass "Регистрация без PostgreSQL → $CODE" +else + fail "Регистрация без PostgreSQL (expected 500/503, got=$CODE)" +fi + +HEALTH=$(curl -s -o /dev/null -w "%{http_code}" $BASE_URL/api/v1/users/me) +check_status "401" "$HEALTH" "API не падает без PostgreSQL" + +echo "[INFO] Восстанавливаем PostgreSQL..." +docker compose start postgres +sleep 5 + +echo "" +echo "Итоги" +echo "Пройдено: $PASSES" +echo "Упало: $FAILURES" +if [ $FAILURES -eq 0 ]; then + echo "Все тесты отказов пройдены!" + exit 0 +else + exit 1 +fi \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..33d9a337 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,18 @@ +#!/bin/sh +set -eu + +# Перезапускаем все сервисы, сохраняя volumes +docker compose restart api postgres redis + +# Ждем, пока API снова станет готовым (healthcheck) +echo "Waiting for API to be ready..." +for i in {1..15}; do + if curl -sf http://localhost:8080/health/ready > /dev/null; then + echo "API is ready." + exit 0 + fi + sleep 1 +done + +echo "API failed to become ready after restart." +exit 1 \ No newline at end of file diff --git a/src/DEMO.md b/src/DEMO.md new file mode 100644 index 00000000..e38db717 --- /dev/null +++ b/src/DEMO.md @@ -0,0 +1,319 @@ +# Демо — лабораторная 2 (защита на оценку 4) + +**Автор:** Тюрина Александра, БВТ2304 +**Целевая оценка:** 4 (весь уровень 3 + весь уровень 4; трек 5 не заявлен) +**Стенд:** `docker compose` (api + postgres + redis), порт `127.0.0.1:8080` +**Хронометраж:** ~15–20 минут. Блоки 1–2 обязательны; 3–12 закрывают рубрику 4. + +> Как пользоваться: каждая команда ниже воспроизводима из чистого clone. Серые блоки — то, что вводишь в терминал; курсив `Сказать:` — что проговариваешь вслух, чтобы показать понимание. Если вывод совпадает с «Ожидаем» — блок закрыт, идём дальше. Не подгоняй тест под приложение и не ослабляй assertions (правило курса). + +--- + +## 0. Подготовка: поднять стенд из чистого clone + +```bash +git clone +cd mtusi2026lab2-fork +cp .env.example .env # локальный конфиг, в git не попадает +docker compose --env-file .env up -d --build +``` + +*Сказать:* «Весь стек поднимается одной командой из репозитория: API, PostgreSQL и Redis. Ссылка „у меня БД уже установлена“ не заменяет воспроизводимость — зависимости объявлены в compose и поднимаются отсюда же.» + +Дождаться готовности (healthcheck api зависит от healthy postgres/redis): + +```bash +until curl -fsS http://localhost:8080/health/ready >/dev/null; do sleep 1; done +docker compose ps +``` + +**Ожидаем:** все три сервиса `Up (healthy)`. + +```text +NAME STATUS +mtusi2026lab2-fork-api-1 Up (healthy) +mtusi2026lab2-fork-postgres-1 Up (healthy) +mtusi2026lab2-fork-redis-1 Up (healthy) +``` + +*Сказать:* «`depends_on.condition: service_healthy` гарантирует, что API стартует только после готовности БД и Redis — миграции не упадут на ещё не поднявшемся Postgres.» + +--- + +## 1. Уровень 3: публичный контракт проходит + +```bash +make test +``` + +**Ожидаем:** зелёный прогон `tests/smoke.py` без `FAIL`. + +*Сказать:* «Все эндпоинты lab1, форматы ошибок, членство в чатах и курсорная пагинация соответствуют `contracts/openapi.json`. В lab2 добавились password при регистрации, Basic→Bearer и отзыв сессии — smoke это проверяет. Контракт я не меняла ради зелёного результата.» + +--- + +## 2. Уровень 4, пункт «собственные тесты одной командой» + +```bash +python3 student-tests/run-test.py --base-url http://localhost:8080 +``` + +**Ожидаем:** `ALL STUDENT TESTS PASSED`. Пройдись вслух по покрытым кейсам (это буквальные пункты рубрики 4): + +| Кейс рубрики 4 | Проверка в тесте | Код | +|---|---|---| +| неверный JSON | `malformed JSON -> 400` | 400 `invalid_request` | +| чужой чат | `outsider GET chat -> 404`, `outsider send -> 404`, `outsider list hides foreign chat` | 404, без утечки | +| пустое сообщение | `empty message -> 400`, `whitespace message -> 400` | 400 | +| дубликат username | `duplicate username -> 409` | 409 `conflict` | +| обход нескольких страниц | `pagination multi-page (>1)`, `no repeats & >=26`, `history ordered by (created_at,id)` | курсор, порядок строгий | +| + валидация контракта | `wrong Content-Type -> 415`, `unknown route -> 404 envelope`, `username pattern -> 400`, `password too short -> 400` | 415/404/400 | +| + аутентификация lab2 | `X-User-Id (lab1) rejected -> 401`, `Basic on /users/me -> 401`, `me matches alice (read-after-write)`, `logout 204`, `token revoked -> 401` | 401/200/204 | + +*Сказать:* «Тесты — отдельный файл, запускаются одной командой, не ослабляют публичные проверки. Особо обращаю внимание на `read-after-write`: сразу после входа `/users/me` возвращает именно владельца токена — это проверяет, что сессия записалась и читается согласованно.» + +--- + +## 3. Уровень 4, пункт «защита от гонок»: 100 сообщений от 10 клиентов + +Тот же запуск `run-test.py` содержит конкурентный блок (10 потоков × 10 сообщений в один чат, затем чтение истории). Вывод: + +```text +[PASS] 100 concurrent sends all 201 +[PASS] exactly 100 unique messages +``` + +*Сказать:* «В lab1 гонки закрывались `sync.RWMutex` над `map`. В lab2 общего изменяемого состояния в процессе нет — целостность обеспечивает PostgreSQL: каждая вставка — атомарный `INSERT … RETURNING` в транзакции соединения пула, а порядок истории задаётся `ORDER BY created_at, id`, курсор сравнивает пары `(created_at, id) > (…)`. Поэтому параллельные вставки не дают ни потерь, ни дублей, ни инверсий порядка — ровно 100 уникальных ID.» + +Проверка руками (опционально, если преподаватель попросит «покажи»: + +```bash +docker compose exec -T postgres psql -U lab2 -d lab2 -c \ + "SELECT count(*), count(DISTINCT id) FROM messages;" +``` +**Ожидаем:** `count` = `count(DISTINCT id)` — дублей нет. + +--- + +## 4. Аутентификация lab2 руками: Basic → Bearer → отзыв + +```bash +# регистрация (password обязателен с lab2) +ALICE=$(curl -s -X POST http://localhost:8080/api/v1/users \ + -H 'Content-Type: application/json' \ + -d '{"username":"alice_demo","display_name":"Алиса","password":"SecurePassword123!"}') +ALICE_ID=$(echo "$ALICE" | python3 -c 'import sys,json;print(json.load(sys.stdin)["id"])') + +# вход ТОЛЬКО через Basic (base64 user:pass), JSON-тела нет +CREDS=$(printf 'alice_demo:SecurePassword123!' | base64) +SESS=$(curl -s -X POST http://localhost:8080/api/v1/auth/sessions -H "Authorization: Basic $CREDS") +TOKEN=$(echo "$SESS" | python3 -c 'import sys,json;print(json.load(sys.stdin)["token"])') + +# защищённый запрос — Bearer +curl -s http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" + +# lab1-стиль больше не принимается +curl -s -o /dev/null -w '%{http_code}\n' http://localhost:8080/api/v1/users/me -H "X-User-Id: $ALICE_ID" + +# отзыв сессии и повтор +curl -s -o /dev/null -w '%{http_code}\n' -X DELETE http://localhost:8080/api/v1/auth/sessions/current -H "Authorization: Bearer $TOKEN" +curl -s -o /dev/null -w '%{http_code}\n' http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" +``` + +**Ожидаем:** `200` на `/users/me` с Bearer; `401` на `X-User-Id`; `204` на logout; `401` после logout. + +*Сказать:* «Basic — это кодирование, не шифрование, и принимается только на создании сессии; дальше всё ходит по Bearer. Пароль хранится как bcrypt‑хэш, в JSON‑ответах поля `password_hash` нет (`json:"-"`). Сам токен в хранилищах кладётся только как SHA‑256 — утечка БД или Redis не раскрывает живой токен. Повторный logout/запрос мёртвым токеном даёт 401, потому что `DELETE /auth/sessions/current` стоит за `BearerAuthMiddleware`: middleware валидирует токен до обработчика.» + +> Честное ограничение (могут спросить): bcrypt обрезает пароль после 72 байт. Контракт это допускает («bcrypt с учётом ограничений библиотеки»), диапазон 12–128 code points я валидирую до хеширования; в lab7 обязателен Argon2id, куда я и перейду. *Сказать это вслух — плюс к пониманию, а не минус.* + +--- + +## 5. Уровень 4, специфика lab2: персистентность и проверяемый рестарт (Redis AOF + Postgres fallback) + +Сначала убеждаемся, что токен жив **до** рестарта, затем рестартуем **без потери volumes** и проверяем тот же токен **после**. + +```bash +# живой токен и данные (создадим чат+сообщение, если ещё нет) +curl -s http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" -o /dev/null -w 'before: %{http_code}\n' + +# проверяемый рестарт: перезапуск контейнеров С СОХРАНЕНИЕМ volumes +./scripts/restart.sh +``` + +`scripts/restart.sh` делает `docker compose restart api postgres redis` (никакого `down -v`, никакого flush) и ждёт `/health/ready`. После него: + +```bash +curl -s http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" -o /dev/null -w 'after: %{http_code}\n' +docker compose exec -T postgres psql -U lab2 -d lab2 -c "SELECT count(*) FROM messages;" +``` + +**Ожидаем:** `before: 200`, `after: 200` (тот же токен работает), `count` не изменился — данные целы. + +*Сказать:* «В отличие от lab1, где рестарт сбрасывал состояние (ожидаемо), здесь состояние переживает рестарт двумя независимыми механизмами. Первый — Redis запущен с `--appendonly yes --appendfsync everysec` и named‑volume `redis_data`: сессии переживают рестарт самого Redis. Второй — PostgreSQL как источник истины: при входе сессия пишется и в Redis, и в таблицу `sessions`; middleware при промахе в Redis делает fallback в Postgres и проверяет `expires_at > NOW()`. Даже если AOF потерян, живая сессия восстановится из БД. Важный нюанс контракта: TTL **не продлевается** из‑за рестарта — `expires_at` фиксирован в момент входа, рестарт его не сдвигает.» + +Полный пайплайн рубрики: + +```bash +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` +**Ожидаем:** зелёный (после рестарта прежние сессии/данные валидны; после logout — 401). + +--- + +## 6. Уровень 4, специфика lab2: роль Redis + эксперимент отказа зависимости + +Это буквальный пункт рубрики: «показать роль Redis/Valkey, план SQL и ошибку зависимости». Роль уже показана в блоке 5 (кэш сессий + AOF). Теперь — отказ. + +### 6а. Отказ Redis → API деградирует gracefully (fallback в Postgres) + +```bash +docker compose stop redis +# вход всё ещё работает (пишем в Postgres; Redis-сетку ловим и игнорируем на fast-path) +curl -s -o /dev/null -w 'login w/o redis: %{http_code}\n' -X POST http://localhost:8080/api/v1/auth/sessions -H "Authorization: Basic $CREDS" +# проверка старого токена идёт через Postgres-fallback +curl -s -o /dev/null -w 'me w/o redis: %{http_code}\n' http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" +# readiness отражает деградацию зависимости +curl -s -o /dev/null -w 'ready w/o redis: %{http_code}\n' http://localhost:8080/health/ready +docker compose start redis +``` + +**Ожидаем:** `login`/`me` = `200` (сервис жив благодаря Postgres), `ready` может стать `503`/нестабильным — процесс при этом **не падает**. + +*Сказать:* «Redis — ускоритель, а не единственная точка отказа. При его недоступности быстрый путь в middleware промахивается и уходит в Postgres‑fallback; пул Redis настроен с таймаутами dial/read/write 3s и `PoolSize=20/MinIdleConns=5`, поэтому зависание Redis не вешает HTTP‑воркеры. Именно поэтому я держу сессию и в Redis, и в Postgres — это и есть „роль Redis с конкретным назначением“, которую требует рубрика, а не просто установленный контейнер.» + +### 6б. Отказ PostgreSQL → 503 без внутренних деталей, процесс жив + +```bash +docker compose stop postgres +curl -s -o /dev/null -w 'me w/o db: %{http_code}\n' http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" +curl -s http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $TOKEN" # тело ошибки +docker compose start postgres +``` + +**Ожидаем:** `503`, тело — единый error‑конверт `{"error":{"code":"unavailable",…,"request_id":…}}` **без** stack trace и деталей коннекта; контейнер api не перезапускается сам по себе. + +*Сказать:* «Ошибка зависимости маппится в 503 `unavailable` по контракту, внутренние детали (строка подключения, паники pgx) наружу не уходят; `request_id` в ответе позволяет соотнести с логом. Процесс остаётся живым — это обработка отказа, а не падение.» + +> `scripts/failure_tests.sh` в репозитории написан под локальный `go run` (использует `pkill`); для compose‑стенда выше — эквивалентные шаги руками через `docker compose stop/start`. Оба варианта воспроизводимы; в отчёте это отмечено честно. + +--- + +## 7. Уровень 4, специфика lab2: SQL‑план курсорной пагинации + +Пункт рубрики «план SQL». Показываем, что глубокая страница истории идёт индексом, а не seq‑scan + sort. + +```bash +# список индексов на messages +docker compose exec -T postgres psql -U lab2 -d lab2 -c \ + "SELECT indexname, indexdef FROM pg_indexes WHERE tablename='messages';" + +# берём любой chat_id, который уже наполнен тестами +CID=$(docker compose exec -T postgres psql -U lab2 -d lab2 -tAc \ + "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1") + +# план первой и «глубокой» страницы +docker compose exec -T postgres psql -U lab2 -d lab2 -c \ + "EXPLAIN (ANALYZE, BUFFERS) SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id='$CID' ORDER BY created_at,id LIMIT 10;" +``` + +**Ожидаем в плане:** `Index Scan`/`Index Only Scan` по составному индексу `(chat_id, created_at, id)`, узел `Sort` отсутствует (порядок даёт индекс), `rows removed by filter` минимальны, `shared hit` >> `shared read` на повторе. + +*Сказать:* «Курсор сравнивает пары `(created_at, id) > (…)`, поэтому индекс именно составной с `id` как тай‑брейком — иначе на одинаковых `created_at` пришлось бы досортировывать и делать heap‑fetch. Один запрос `LIMIT+1` (см. ниже) даёт и страницу, и признак „есть следующая“ без отдельного `COUNT`/`EXISTS` — это осознанный выбор для высоконагруженного чтения.» + +> Про `LIMIT+1`: наивное `next_cursor = (len==limit)` ломается, когда полная страница оказывается последней (тест `second page must finish history` падает). Я запрашиваю на одну запись больше: если получили `> limit` — режем до `limit` и ставим курсор; иначе `next_cursor = null`. Это видно в `postgres.go` (`GetMessages`, `ListChats`). + +--- + +## 8. Уровень 4: Docker‑практики + +```bash +# непривилегированный пользователь +docker compose exec -T api id +# multi-stage: в рантайме только бинарник, нет Go-тулчейна +docker compose exec -T api sh -c 'ls -la /app && ! command -v go' +# закрепленные версии (никакого latest) +grep -E 'image:|FROM' docker-compose.yml Dockerfile +# .dockerignore исключает секреты/артефакты из контекста +head -n 20 .dockerignore +# healthcheck в образе +grep -A1 HEALTHCHECK Dockerfile +``` + +**Ожидаем:** `uid=100(app) …` (не `uid=0`); `go` в рантайме нет; теги `golang:1.22-alpine`, `alpine:3.20`, `postgres:16-alpine`, `redis:7-alpine`; в `.dockerignore` — `.git`, `.env*`, `secrets`, `volumes`, `__pycache__` и т.п.; `HEALTHCHECK` на `/health/ready`. + +*Сказать:* «Сборка и рантайм разделены (multi‑stage), базовые образы закреплены по тегу, контейнер работает от непривилегированного `app`, `.dockerignore` не тащит в образ ни секреты, ни `.git`, ни кэш Python. Healthcheck в Dockerfile + `service_healthy` в compose — это и готовность, и зависимость старта.» + +--- + +## 9. Уровень 4: graceful shutdown (SIGTERM ≤ 10s) и полезные логи + +```bash +time docker compose stop api +docker compose logs api --tail=8 +``` + +**Ожидаем:** `real 0m0.xs` (≪ 10s); в хвосте лога — `INFO: Shutting down server...` и `INFO: Server exited properly`; в логах **нет** тел сообщений, паролей и токенов, есть `метод путь длительность [request_id=…]`. + +*Сказать:* «`main.go` ловит SIGTERM/SIGINT, вызывает `srv.Shutdown` с контекстом 5s и `SetKeepAlivesEnabled(false)` — новые соединения перестают приниматься, активные дозавершаются, поэтому укладывается в бюджет ≤10s. Логи структурированы и содержат `request_id` для трассировки, но содержимое сообщений и креденшелы в stdout не пишутся — это требование безопасности рубрики.» + +Проверка, что сообщений нет в логах (должно быть пусто): + +```bash +docker compose logs api 2>&1 | grep -iE 'Привет|password|Bearer [A-Za-z0-9]' || echo 'OK: no secrets/message bodies in logs' +``` + +--- + +## 10. Уровень 4: идемпотентность миграций + +```bash +docker compose restart api +docker compose logs api --tail=5 | grep -i migration +``` + +**Ожидаем:** `INFO: Skipping migration 001_initial.sql (already applied)` — повторный старт не дублирует схему и данные. + +*Сказать:* «Миграции вшиты через `embed.FS` и применяются в транзакции с записью версии в `schema_migrations`; таблица создаётся `IF NOT EXISTS`, версия проверяется — поэтому рестарт и `make test-persistence` безопасны, схема и данные сохранены.» + +--- + +## 11. Уровень 4: секреты и volumes вне Git + +```bash +git status --porcelain | grep -E '\.env$|volumes/|secrets/' || echo 'clean: secrets/volumes not tracked' +git ls-files | grep -E '\.env$|volumes/' || echo 'clean: nothing sensitive committed' +``` + +**Ожидаем:** `clean: …` — ни `.env`, ни volumes, ни секретов в индексе; в репозитории только `.env.example` с логическими именами переменных. + +*Сказать:* «Локальный `.env` создаётся из примера и не коммитится (`.gitignore` + `.dockerignore`); данные БД/Redis живут в named‑volumes, которые не часть репозитория. Учётные данные в compose (`lab2/lab2`) — синтетические учебные креды изолированного стенда, не реальные секреты; в отчёте и evidence они обезличены.» + +--- + +## 12. Итог по рубрике 4 (считаем галочки вслух) + +| Пункт уровня 4 | Где закрыт | Статус | +|---|---|---| +| Весь уровень 3 (контракт, smoke) | блок 1 | ✅ | +| Собственные тесты: 400/415/404‑конверт, чужой чат, пустое сообщение, дубликат username, многостраничная пагинация — одной командой | блок 2 | ✅ | +| Защита от гонок: 100 сообщений / 10 клиентов → ровно 100 уникальных | блок 3 | ✅ | +| Non‑root, multi‑stage, закрепленные версии, `.dockerignore`, healthcheck | блок 8 | ✅ | +| SIGTERM ≤ 10s, новые запросы не принимаются, логи без содержимого сообщений | блок 9 | ✅ | +| Роль Redis/Valkey + persistence, выдерживающий проверяемый рестарт | блоки 5, 6а | ✅ | +| План SQL (EXPLAIN) курсорной пагинации | блок 7 | ✅ | +| Ошибка зависимости (Redis down → fallback; DB down → 503, процесс жив) | блок 6 | ✅ | +| Идемпотентные миграции | блок 10 | ✅ | +| Секреты/volumes вне Git | блок 11 | ✅ | + +*Сказать (финал):* «Все пункты рубрики 4 реализованы, проверены и воспроизводимы из чистого clone; каждое доказательство выше — это команда и её вывод, а не скриншот. Трек 5 я не заявляла в эту сдачу; при интересе могу показать дорожную карту по Треку 2 (план запроса и восстановление: ≥100k сообщений, сравнение ≥2 индексов, `pg_dump`→restore→сверка) — она описана в `REPORT.md`, но в четвёрку не входит.» + +--- + +## Приложение. Ответы на вероятные вопросы защиты + +- **Почему сессия и в Redis, и в Postgres, а не только Redis?** «Рубрика требует role с persistence, выдерживающей проверяемый рестарт. Redis с AOF это даёт, но Postgres — источник истины и страховка от потери AOF; fallback в middleware делает систему устойчивой к отказу кэша (блок 6а).» +- **Почему `LIMIT+1`, а не `COUNT`?** «Один запрос вместо двух; `COUNT` на большой истории дорог и не нужен — признак следующей страницы даёт лишний прочитанный ряд.» +- **Где гонки, если mutex’а нет?** «Их нет на уровне приложения: нет общего изменяемого состояния в процессе;串行изация — в PostgreSQL на уровне транзакций соединения, порядок — индексом `(chat_id, created_at, id)`.» +- **bcrypt и 72 байта?** «Ограничение библиотеки, контракт его допускает с оговоркой; диапазон 12–128 валидирую до хеширования, в lab7 — Argon2id.» +- **Почему 401 на `X-User-Id` в lab2?** «Объявленный переход 1→2: `X-User-Id` не был аутентификацией; теперь только Bearer, старый заголовок отвергается (блок 4, тест `X-User-Id (lab1) rejected -> 401`).» +- **TTL после рестарта?** «Не продлевается — `expires_at` фиксирован при входе; рестарт сохраняет, но не сдвигает дедлайн (блок 5).» \ No newline at end of file diff --git a/src/cmd/server/main.go b/src/cmd/server/main.go new file mode 100644 index 00000000..cd2e6817 --- /dev/null +++ b/src/cmd/server/main.go @@ -0,0 +1,141 @@ +package main + +import ( + "context" + "log" + "net/http" + "os" + "os/signal" + "strconv" + "syscall" + "time" + + "mtusi2026lab2-fork/src/internal/handler" + "mtusi2026lab2-fork/src/internal/session" + "mtusi2026lab2-fork/src/internal/store" + + "github.com/go-chi/chi/v5" + "github.com/go-chi/chi/v5/middleware" + "github.com/google/uuid" +) + +func RequestIDMiddleware(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + requestID := uuid.New().String() + w.Header().Set("X-Request-Id", requestID) + ctx := context.WithValue(r.Context(), handler.RequestIDKey, requestID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func main() { + dbURL := os.Getenv("DATABASE_URL") + if dbURL == "" { + dbURL = "postgres://lab2:lab2@postgres:5432/lab2?sslmode=disable" + } + log.Printf("INFO: Connecting to PostgreSQL...") + + pgStore, err := store.NewPostgres(dbURL) + if err != nil { + log.Fatalf("ERROR: Failed to connect to database: %v", err) + } + defer pgStore.Close() + log.Printf("INFO: PostgreSQL connected and migrations applied") + + redisURL := os.Getenv("REDIS_URL") + if redisURL == "" { + redisURL = "redis://redis:6379/0" + } + + sessionTTL := 24 * time.Hour + if ttlStr := os.Getenv("SESSION_TTL_SECONDS"); ttlStr != "" { + if secs, err := strconv.Atoi(ttlStr); err == nil && secs > 0 { + sessionTTL = time.Duration(secs) * time.Second + } + } + log.Printf("INFO: Connecting to Redis (session TTL = %v)...", sessionTTL) + + redisStore, err := session.NewRedisStore(redisURL, sessionTTL) + if err != nil { + log.Fatalf("ERROR: Failed to connect to Redis: %v", err) + } + defer redisStore.Close() + log.Printf("INFO: Redis connected") + + h := handler.New(pgStore, redisStore, sessionTTL) + + r := chi.NewRouter() + r.Use(RequestIDMiddleware) + r.Use(middleware.RealIP) + r.Use(middleware.Recoverer) + r.Use(func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + next.ServeHTTP(w, r) + requestID, _ := r.Context().Value(handler.RequestIDKey).(string) + log.Printf("INFO: %s %s %v [request_id=%s]", r.Method, r.URL.Path, time.Since(start), requestID) + }) + }) + + r.Get("/health/live", h.HealthLive) + r.Get("/health/ready", h.HealthReady) + + r.Route("/api/v1", func(r chi.Router) { + r.Post("/users", h.CreateUser) + r.Post("/auth/sessions", h.CreateSession) + + r.Group(func(r chi.Router) { + r.Use(h.BearerAuthMiddleware) + + r.Delete("/auth/sessions/current", h.DeleteSession) + r.Get("/users/me", h.GetMe) + r.Get("/chats", h.ListChats) + r.Post("/chats", h.CreateChat) + r.Get("/chats/{chat_id}", h.GetChat) + r.Post("/chats/{chat_id}/messages", h.SendMessage) + r.Get("/chats/{chat_id}/messages", h.GetMessages) + }) + }) + + r.NotFound(func(w http.ResponseWriter, r *http.Request) { + requestID, _ := r.Context().Value(handler.RequestIDKey).(string) + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusNotFound) + w.Write([]byte(`{"error":{"code":"not_found","message":"Not Found","request_id":"` + requestID + `"}}`)) + }) + + port := os.Getenv("PORT") + if port == "" { + port = "8080" + } + + srv := &http.Server{ + Addr: "0.0.0.0:" + port, + Handler: r, + ReadTimeout: 10 * time.Second, + WriteTimeout: 10 * time.Second, + IdleTimeout: 15 * time.Second, + } + + go func() { + log.Printf("INFO: Server starting on port %s", port) + if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { + log.Fatalf("ERROR: Server failed to start: %v", err) + } + }() + + quit := make(chan os.Signal, 1) + signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) + <-quit + log.Println("INFO: Shutting down server...") + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + srv.SetKeepAlivesEnabled(false) + if err := srv.Shutdown(ctx); err != nil { + log.Fatalf("ERROR: Server forced to shutdown: %v", err) + } + + log.Println("INFO: Server exited properly") +} diff --git a/src/internal/auth/auth.go b/src/internal/auth/auth.go new file mode 100644 index 00000000..57942bb3 --- /dev/null +++ b/src/internal/auth/auth.go @@ -0,0 +1,46 @@ +package auth + +import ( + "crypto/rand" + "crypto/sha256" + "crypto/subtle" + "encoding/base64" + "encoding/hex" + "time" + + "golang.org/x/crypto/bcrypt" +) + +func HashPassword(password string) (string, error) { + hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost) + if err != nil { + return "", err + } + return string(hash), nil +} + +func CheckPassword(password, hash string) bool { + err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)) + return err == nil +} + +func GenerateToken() (string, error) { + b := make([]byte, 32) + if _, err := rand.Read(b); err != nil { + return "", err + } + return base64.URLEncoding.EncodeToString(b), nil +} + +func HashToken(token string) string { + h := sha256.Sum256([]byte(token)) + return hex.EncodeToString(h[:]) +} + +func SecureCompare(a, b string) bool { + return subtle.ConstantTimeCompare([]byte(a), []byte(b)) == 1 +} + +func IsSessionExpired(expiresAt time.Time) bool { + return time.Now().After(expiresAt) +} diff --git a/src/internal/handler/handler.go b/src/internal/handler/handler.go new file mode 100644 index 00000000..0b8a1719 --- /dev/null +++ b/src/internal/handler/handler.go @@ -0,0 +1,434 @@ +package handler + +import ( + "context" + "encoding/base64" + "encoding/json" + "errors" + "log" + "net/http" + "strconv" + "strings" + "time" + + "mtusi2026lab2-fork/src/internal/auth" + "mtusi2026lab2-fork/src/internal/model" + "mtusi2026lab2-fork/src/internal/store" + + "github.com/go-chi/chi/v5" +) + +type CtxKey string + +const RequestIDKey CtxKey = "request_id" +const UserIDKey CtxKey = "user_id" + +type SessionStore interface { + Get(ctx context.Context, tokenHash string) (string, error) + Set(ctx context.Context, userID, tokenHash string, ttl time.Duration) error + Delete(ctx context.Context, tokenHash string) error +} + +type Handler struct { + store store.Store + sessionStore SessionStore + sessionTTL time.Duration +} + +func New(s store.Store, ss SessionStore, ttl time.Duration) *Handler { + return &Handler{ + store: s, + sessionStore: ss, + sessionTTL: ttl, + } +} + +func userToMap(u *model.User) map[string]interface{} { + return map[string]interface{}{ + "id": u.ID, + "username": u.Username, + "display_name": u.DisplayName, + "created_at": u.CreatedAt.UTC().Format(time.RFC3339), + } +} + +func respondError(w http.ResponseWriter, r *http.Request, code int, errorCode string) { + requestID, _ := r.Context().Value(RequestIDKey).(string) + log.Printf("ERROR: %d - %s [request_id=%s]", code, errorCode, requestID) + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(code) + json.NewEncoder(w).Encode(map[string]interface{}{ + "error": map[string]string{ + "code": errorCode, + "message": http.StatusText(code), + "request_id": requestID, + }, + }) +} + +func respondJSON(w http.ResponseWriter, code int, data interface{}) { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(code) + json.NewEncoder(w).Encode(data) +} + +func checkContentType(r *http.Request) bool { + ct := r.Header.Get("Content-Type") + return ct == "application/json" || strings.HasPrefix(ct, "application/json;") +} + +func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) { + if !checkContentType(r) { + respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type") + return + } + var req struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + } + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + if err := decoder.Decode(&req); err != nil { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + + if len(req.Password) < 12 || len(req.Password) > 128 { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + + passwordHash, err := auth.HashPassword(req.Password) + if err != nil { + respondError(w, r, http.StatusInternalServerError, "internal_error") + return + } + + user, err := h.store.CreateUser(r.Context(), req.Username, req.DisplayName, passwordHash) + if err != nil { + if errors.Is(err, store.ErrConflict) { + respondError(w, r, http.StatusConflict, "conflict") + } else { + respondError(w, r, http.StatusBadRequest, "invalid_request") + } + return + } + respondJSON(w, http.StatusCreated, userToMap(user)) +} + +func (h *Handler) CreateSession(w http.ResponseWriter, r *http.Request) { + authHeader := r.Header.Get("Authorization") + if !strings.HasPrefix(authHeader, "Basic ") { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + payload, err := base64.StdEncoding.DecodeString(strings.TrimPrefix(authHeader, "Basic ")) + if err != nil { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + parts := strings.SplitN(string(payload), ":", 2) + if len(parts) != 2 { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + username, password := parts[0], parts[1] + + user, err := h.store.GetUserByUsername(r.Context(), username) + if err != nil || !auth.CheckPassword(password, user.PasswordHash) { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + token, err := auth.GenerateToken() + if err != nil { + respondError(w, r, http.StatusInternalServerError, "internal_error") + return + } + + tokenHash := auth.HashToken(token) + expiresAt := time.Now().Add(h.sessionTTL) + + if _, err := h.store.CreateSession(r.Context(), user.ID, tokenHash, expiresAt); err != nil { + respondError(w, r, http.StatusServiceUnavailable, "unavailable") + return + } + + if err := h.sessionStore.Set(r.Context(), user.ID, tokenHash, h.sessionTTL); err != nil { + _ = h.store.DeleteSession(r.Context(), tokenHash) // компенсация (best‑effort) + respondError(w, r, http.StatusServiceUnavailable, "unavailable") + return + } + + response := map[string]interface{}{ + "token": token, + "token_type": "Bearer", + "expires_at": expiresAt.UTC().Format(time.RFC3339), + "user": userToMap(user), + } + respondJSON(w, http.StatusCreated, response) +} + +func (h *Handler) DeleteSession(w http.ResponseWriter, r *http.Request) { + authHeader := r.Header.Get("Authorization") + if !strings.HasPrefix(authHeader, "Bearer ") { + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + token := strings.TrimPrefix(authHeader, "Bearer ") + tokenHash := auth.HashToken(token) + + if err := h.store.DeleteSession(r.Context(), tokenHash); err != nil { + respondError(w, r, http.StatusServiceUnavailable, "unavailable") + return + } + if err := h.sessionStore.Delete(r.Context(), tokenHash); err != nil { + respondError(w, r, http.StatusServiceUnavailable, "unavailable") + return + } + + w.WriteHeader(http.StatusNoContent) +} + +func (h *Handler) BearerAuthMiddleware(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + authHeader := r.Header.Get("Authorization") + if !strings.HasPrefix(authHeader, "Bearer ") { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + token := strings.TrimPrefix(authHeader, "Bearer ") + tokenHash := auth.HashToken(token) + + userID, err := h.sessionStore.Get(r.Context(), tokenHash) + if err != nil { + session, errPg := h.store.GetSession(r.Context(), tokenHash) + if errPg != nil || auth.IsSessionExpired(session.ExpiresAt) { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + userID = session.UserID + } + + ctx := context.WithValue(r.Context(), UserIDKey, userID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func (h *Handler) GetMe(w http.ResponseWriter, r *http.Request) { + userID, ok := r.Context().Value(UserIDKey).(string) + if !ok { + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + user, err := h.store.GetUserByID(r.Context(), userID) + if err != nil { + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + respondJSON(w, http.StatusOK, userToMap(user)) +} + +func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) { + if !checkContentType(r) { + respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type") + return + } + userID, ok := r.Context().Value(UserIDKey).(string) + if !ok { + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + var req struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + } + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + if err := decoder.Decode(&req); err != nil { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + + isMember := false + for _, id := range req.MemberIDs { + if id == userID { + isMember = true + break + } + } + if !isMember { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + + chat, err := h.store.CreateChat(r.Context(), req.Title, req.MemberIDs) + if err != nil { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + + if chat.MemberIDs == nil { + chat.MemberIDs = []string{} + } + + respondJSON(w, http.StatusCreated, chat) +} + +func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) { + userID, ok := r.Context().Value(UserIDKey).(string) + if !ok { + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + limitStr := r.URL.Query().Get("limit") + limit := 50 + if limitStr != "" { + parsed, err := strconv.Atoi(limitStr) + if err != nil || parsed < 1 || parsed > 100 { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + limit = parsed + } + cursor := r.URL.Query().Get("cursor") + chats, nextCursor, err := h.store.ListChats(r.Context(), userID, limit, cursor) + if err != nil { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + + if chats == nil { + chats = []*model.Chat{} + } + + for _, c := range chats { + if c.MemberIDs == nil { + c.MemberIDs = []string{} + } + } + + respondJSON(w, http.StatusOK, map[string]interface{}{ + "items": chats, + "next_cursor": nextCursor, + }) +} + +func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) { + chatID := chi.URLParam(r, "chat_id") + userID, ok := r.Context().Value(UserIDKey).(string) + if !ok { + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + chat, err := h.store.GetChat(r.Context(), chatID, userID) + if err != nil { + if errors.Is(err, store.ErrNotFound) { + respondError(w, r, http.StatusNotFound, "not_found") + } else { + respondError(w, r, http.StatusBadRequest, "invalid_request") + } + return + } + + if chat.MemberIDs == nil { + chat.MemberIDs = []string{} + } + + respondJSON(w, http.StatusOK, chat) +} + +func (h *Handler) SendMessage(w http.ResponseWriter, r *http.Request) { + if !checkContentType(r) { + respondError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type") + return + } + chatID := chi.URLParam(r, "chat_id") + userID, ok := r.Context().Value(UserIDKey).(string) + if !ok { + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + var req struct { + Text string `json:"text"` + } + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + if err := decoder.Decode(&req); err != nil { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + + msg, err := h.store.AddMessage(r.Context(), chatID, userID, req.Text) + if err != nil { + if errors.Is(err, store.ErrNotFound) { + respondError(w, r, http.StatusNotFound, "not_found") + } else { + respondError(w, r, http.StatusBadRequest, "invalid_request") + } + return + } + respondJSON(w, http.StatusCreated, msg) +} + +func (h *Handler) GetMessages(w http.ResponseWriter, r *http.Request) { + chatID := chi.URLParam(r, "chat_id") + userID, ok := r.Context().Value(UserIDKey).(string) + if !ok { + respondError(w, r, http.StatusUnauthorized, "unauthorized") + return + } + + cursor := r.URL.Query().Get("cursor") + limitStr := r.URL.Query().Get("limit") + limit := 50 + if limitStr != "" { + parsed, err := strconv.Atoi(limitStr) + if err != nil || parsed < 1 || parsed > 100 { + respondError(w, r, http.StatusBadRequest, "invalid_request") + return + } + limit = parsed + } + + messages, nextCursor, err := h.store.GetMessages(r.Context(), chatID, userID, cursor, limit) + if err != nil { + if errors.Is(err, store.ErrNotFound) { + respondError(w, r, http.StatusNotFound, "not_found") + } else { + respondError(w, r, http.StatusBadRequest, "invalid_request") + } + return + } + + if messages == nil { + messages = []*model.Message{} + } + + respondJSON(w, http.StatusOK, map[string]interface{}{ + "items": messages, + "next_cursor": nextCursor, + }) +} + +func (h *Handler) HealthLive(w http.ResponseWriter, r *http.Request) { + respondJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} + +func (h *Handler) HealthReady(w http.ResponseWriter, r *http.Request) { + respondJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} diff --git a/src/internal/model/model.go b/src/internal/model/model.go new file mode 100644 index 00000000..d8912571 --- /dev/null +++ b/src/internal/model/model.go @@ -0,0 +1,34 @@ +package model + +import "time" + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` + PasswordHash string `json:"-"` // Никогда не отдаём в JSON +} + +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt time.Time `json:"created_at"` +} + +type Session struct { + ID string `json:"-"` + UserID string `json:"-"` + TokenHash string `json:"-"` + ExpiresAt time.Time `json:"expires_at"` + CreatedAt time.Time `json:"created_at"` +} diff --git a/src/internal/session/redis_store.go b/src/internal/session/redis_store.go new file mode 100644 index 00000000..c0fe9b3b --- /dev/null +++ b/src/internal/session/redis_store.go @@ -0,0 +1,85 @@ +package session + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/redis/go-redis/v9" +) + +var ( + ErrSessionNotFound = errors.New("session_not_found") + ErrRedisDown = errors.New("redis_unavailable") +) + +type RedisStore struct { + client *redis.Client + ttl time.Duration +} + +func NewRedisStore(redisURL string, ttl time.Duration) (*RedisStore, error) { + opts, err := redis.ParseURL(redisURL) + if err != nil { + return nil, fmt.Errorf("parse redis url: %w", err) + } + + opts.DialTimeout = 3 * time.Second + opts.ReadTimeout = 3 * time.Second + opts.WriteTimeout = 3 * time.Second + opts.PoolSize = 20 + opts.MinIdleConns = 5 + + client := redis.NewClient(opts) + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + if err := client.Ping(ctx).Err(); err != nil { + return nil, fmt.Errorf("redis ping: %w", err) + } + + return &RedisStore{client: client, ttl: ttl}, nil +} + +func (s *RedisStore) Close() error { + return s.client.Close() +} + +func (s *RedisStore) Set(ctx context.Context, userID, tokenHash string, ttl time.Duration) error { + key := fmt.Sprintf("session:%s", tokenHash) + err := s.client.Set(ctx, key, userID, ttl).Err() + if err != nil { + return fmt.Errorf("%w: %v", ErrRedisDown, err) + } + return nil +} + +func (s *RedisStore) Get(ctx context.Context, tokenHash string) (string, error) { + if tokenHash == "" { + return "", ErrSessionNotFound + } + key := fmt.Sprintf("session:%s", tokenHash) + userID, err := s.client.Get(ctx, key).Result() + if err != nil { + if errors.Is(err, redis.Nil) { + return "", ErrSessionNotFound + } + return "", fmt.Errorf("%w: %v", ErrRedisDown, err) + } + return userID, nil +} + +func (s *RedisStore) Delete(ctx context.Context, tokenHash string) error { + key := fmt.Sprintf("session:%s", tokenHash) + err := s.client.Del(ctx, key).Err() + if err != nil { + return fmt.Errorf("%w: %v", ErrRedisDown, err) + } + return nil +} + +func (s *RedisStore) IsAvailable(ctx context.Context) bool { + return s.client.Ping(ctx).Err() == nil +} diff --git a/src/internal/store/migrations/001_initial.sql b/src/internal/store/migrations/001_initial.sql new file mode 100644 index 00000000..f06a5643 --- /dev/null +++ b/src/internal/store/migrations/001_initial.sql @@ -0,0 +1,47 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + username VARCHAR(32) NOT NULL UNIQUE, + display_name VARCHAR(100) NOT NULL, + password_hash VARCHAR(255) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + + CONSTRAINT username_format CHECK (username ~ '^[a-z0-9_]{3,32}$') + ); + +CREATE INDEX idx_users_username ON users(username); + +CREATE TABLE chats ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX idx_chat_members_user ON chat_members(user_id); + +CREATE TABLE messages ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + text TEXT NOT NULL CHECK (length(text) >= 1 AND length(text) <= 4000), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_messages_chat_created ON messages(chat_id, created_at, id); + +CREATE TABLE sessions ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + token_hash VARCHAR(64) NOT NULL UNIQUE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX idx_sessions_token ON sessions(token_hash); +CREATE INDEX idx_sessions_user ON sessions(user_id); +CREATE INDEX idx_sessions_expires ON sessions(expires_at); \ No newline at end of file diff --git a/src/internal/store/postgres.go b/src/internal/store/postgres.go new file mode 100644 index 00000000..fca1ea8a --- /dev/null +++ b/src/internal/store/postgres.go @@ -0,0 +1,555 @@ +package store + +import ( + "context" + "embed" + "errors" + "fmt" + "log" + "time" + + "mtusi2026lab2-fork/src/internal/model" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" +) + +//go:embed migrations/*.sql +var migrationsFS embed.FS + +var ( + ErrInvalidRequest = errors.New("invalid_request") + ErrNotFound = errors.New("not_found") + ErrConflict = errors.New("conflict") + ErrUnauthorized = errors.New("unauthorized") +) + +type Store interface { + CreateUser(ctx context.Context, username, displayName, passwordHash string) (*model.User, error) + GetUserByID(ctx context.Context, id string) (*model.User, error) + GetUserByUsername(ctx context.Context, username string) (*model.User, error) + CreateChat(ctx context.Context, title string, memberIDs []string) (*model.Chat, error) + GetChat(ctx context.Context, chatID, userID string) (*model.Chat, error) + ListChats(ctx context.Context, userID string, limit int, cursor string) ([]*model.Chat, *string, error) + AddMessage(ctx context.Context, chatID, senderID, text string) (*model.Message, error) + GetMessages(ctx context.Context, chatID, userID, cursor string, limit int) ([]*model.Message, *string, error) + CreateSession(ctx context.Context, userID, tokenHash string, expiresAt time.Time) (*model.Session, error) + GetSession(ctx context.Context, tokenHash string) (*model.Session, error) + DeleteSession(ctx context.Context, tokenHash string) error +} + +type PostgresStore struct { + pool *pgxpool.Pool +} + +func NewPostgres(connString string) (*PostgresStore, error) { + config, err := pgxpool.ParseConfig(connString) + if err != nil { + return nil, fmt.Errorf("parse config: %w", err) + } + config.MaxConns = 25 + config.MinConns = 5 + config.MaxConnLifetime = 30 * time.Minute + config.MaxConnIdleTime = 5 * time.Minute + config.HealthCheckPeriod = 30 * time.Second + + pool, err := pgxpool.NewWithConfig(context.Background(), config) + if err != nil { + return nil, fmt.Errorf("create pool: %w", err) + } + + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + if err := pool.Ping(ctx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping database: %w", err) + } + + store := &PostgresStore{pool: pool} + if err := store.applyMigrations(ctx); err != nil { + pool.Close() + return nil, fmt.Errorf("apply migrations: %w", err) + } + + return store, nil +} + +func (s *PostgresStore) Close() { + s.pool.Close() +} + +func (s *PostgresStore) applyMigrations(ctx context.Context) error { + _, err := s.pool.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations ( + version INTEGER PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + )`) + if err != nil { + return fmt.Errorf("create migrations table: %w", err) + } + + var lastVersion int + err = s.pool.QueryRow(ctx, `SELECT COALESCE(MAX(version), 0) FROM schema_migrations`).Scan(&lastVersion) + if err != nil { + return fmt.Errorf("get last version: %w", err) + } + + entries, err := migrationsFS.ReadDir("migrations") + if err != nil { + return fmt.Errorf("read migrations from embed: %w", err) + } + + for _, entry := range entries { + if entry.IsDir() { + continue + } + + var version int + _, err := fmt.Sscanf(entry.Name(), "%d_", &version) + if err != nil { + continue + } + + if version <= lastVersion { + log.Printf("INFO: Skipping migration %s (already applied)", entry.Name()) + continue + } + + content, err := migrationsFS.ReadFile("migrations/" + entry.Name()) + if err != nil { + return fmt.Errorf("read migration %s: %w", entry.Name(), err) + } + + tx, err := s.pool.Begin(ctx) + if err != nil { + return fmt.Errorf("begin tx for %s: %w", entry.Name(), err) + } + + _, err = tx.Exec(ctx, string(content)) + if err != nil { + tx.Rollback(ctx) + return fmt.Errorf("execute migration %s: %w", entry.Name(), err) + } + + _, err = tx.Exec(ctx, `INSERT INTO schema_migrations (version) VALUES ($1)`, version) + if err != nil { + tx.Rollback(ctx) + return fmt.Errorf("insert migration version: %w", err) + } + + if err := tx.Commit(ctx); err != nil { + return fmt.Errorf("commit migration %s: %w", entry.Name(), err) + } + + log.Printf("INFO: Applied migration %s", entry.Name()) + } + + return nil +} + +func (s *PostgresStore) CreateUser(ctx context.Context, username, displayName, passwordHash string) (*model.User, error) { + var user model.User + query := `INSERT INTO users (username, display_name, password_hash) VALUES ($1, $2, $3) RETURNING id, username, display_name, created_at` + err := s.pool.QueryRow(ctx, query, username, displayName, passwordHash).Scan( + &user.ID, &user.Username, &user.DisplayName, &user.CreatedAt, + ) + if err != nil { + if isUniqueViolation(err) { + return nil, ErrConflict + } + return nil, fmt.Errorf("insert user: %w", err) + } + user.CreatedAt = user.CreatedAt.UTC() + return &user, nil +} + +func (s *PostgresStore) GetUserByID(ctx context.Context, id string) (*model.User, error) { + var user model.User + query := `SELECT id, username, display_name, password_hash, created_at FROM users WHERE id = $1` + err := s.pool.QueryRow(ctx, query, id).Scan( + &user.ID, &user.Username, &user.DisplayName, &user.PasswordHash, &user.CreatedAt, + ) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + return nil, fmt.Errorf("get user by id: %w", err) + } + user.CreatedAt = user.CreatedAt.UTC() + return &user, nil +} + +func (s *PostgresStore) GetUserByUsername(ctx context.Context, username string) (*model.User, error) { + var user model.User + query := `SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1` + err := s.pool.QueryRow(ctx, query, username).Scan( + &user.ID, &user.Username, &user.DisplayName, &user.PasswordHash, &user.CreatedAt, + ) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + return nil, fmt.Errorf("get user by username: %w", err) + } + user.CreatedAt = user.CreatedAt.UTC() + return &user, nil +} + +func (s *PostgresStore) CreateChat(ctx context.Context, title string, memberIDs []string) (*model.Chat, error) { + tx, err := s.pool.Begin(ctx) + if err != nil { + return nil, fmt.Errorf("begin tx: %w", err) + } + defer tx.Rollback(ctx) + + var chat model.Chat + query := `INSERT INTO chats (title) VALUES ($1) RETURNING id, created_at` + err = tx.QueryRow(ctx, query, title).Scan(&chat.ID, &chat.CreatedAt) + if err != nil { + return nil, fmt.Errorf("insert chat: %w", err) + } + + for _, userID := range memberIDs { + _, err := tx.Exec(ctx, + `INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)`, + chat.ID, userID, + ) + if err != nil { + return nil, fmt.Errorf("insert member %s: %w", userID, err) + } + } + + if err := tx.Commit(ctx); err != nil { + return nil, fmt.Errorf("commit tx: %w", err) + } + + chat.Title = title + if memberIDs == nil { + chat.MemberIDs = []string{} + } else { + chat.MemberIDs = memberIDs + } + chat.CreatedAt = chat.CreatedAt.UTC() + + return &chat, nil +} + +func (s *PostgresStore) GetChat(ctx context.Context, chatID, userID string) (*model.Chat, error) { + var isMember bool + err := s.pool.QueryRow(ctx, + `SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`, + chatID, userID, + ).Scan(&isMember) + if err != nil { + return nil, fmt.Errorf("check membership: %w", err) + } + if !isMember { + return nil, ErrNotFound + } + + var chat model.Chat + err = s.pool.QueryRow(ctx, + `SELECT id, title, created_at FROM chats WHERE id = $1`, + chatID, + ).Scan(&chat.ID, &chat.Title, &chat.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + return nil, fmt.Errorf("get chat: %w", err) + } + chat.CreatedAt = chat.CreatedAt.UTC() + + chat.MemberIDs = []string{} + + rows, err := s.pool.Query(ctx, + `SELECT user_id FROM chat_members WHERE chat_id = $1`, + chatID, + ) + if err != nil { + return nil, fmt.Errorf("get members: %w", err) + } + defer rows.Close() + + for rows.Next() { + var memberID string + if err := rows.Scan(&memberID); err != nil { + return nil, fmt.Errorf("scan member: %w", err) + } + chat.MemberIDs = append(chat.MemberIDs, memberID) + } + + return &chat, nil +} + +func (s *PostgresStore) ListChats(ctx context.Context, userID string, limit int, cursor string) ([]*model.Chat, *string, error) { + fetchLimit := limit + 1 + + var query string + var args []interface{} + + if cursor == "" { + query = ` + SELECT c.id, c.title, c.created_at + FROM chats c + INNER JOIN chat_members cm ON cm.chat_id = c.id + WHERE cm.user_id = $1 + ORDER BY c.created_at, c.id + LIMIT $2 + ` + args = []interface{}{userID, fetchLimit} + } else { + var cursorCreatedAt time.Time + err := s.pool.QueryRow(ctx, + `SELECT created_at FROM chats WHERE id = $1`, + cursor, + ).Scan(&cursorCreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil, ErrInvalidRequest + } + return nil, nil, fmt.Errorf("get cursor: %w", err) + } + + query = ` + SELECT c.id, c.title, c.created_at + FROM chats c + INNER JOIN chat_members cm ON cm.chat_id = c.id + WHERE cm.user_id = $1 AND (c.created_at, c.id) > ($2, $3) + ORDER BY c.created_at, c.id + LIMIT $4 + ` + args = []interface{}{userID, cursorCreatedAt, cursor, fetchLimit} + } + + rows, err := s.pool.Query(ctx, query, args...) + if err != nil { + return nil, nil, fmt.Errorf("query chats: %w", err) + } + defer rows.Close() + + chats := make([]*model.Chat, 0) + for rows.Next() { + var chat model.Chat + if err := rows.Scan(&chat.ID, &chat.Title, &chat.CreatedAt); err != nil { + return nil, nil, fmt.Errorf("scan chat: %w", err) + } + chat.CreatedAt = chat.CreatedAt.UTC() + chat.MemberIDs = []string{} + chats = append(chats, &chat) + } + + hasMore := len(chats) > limit + if hasMore { + chats = chats[:limit] + } + + if len(chats) > 0 { + chatIDs := make([]string, len(chats)) + for i, c := range chats { + chatIDs[i] = c.ID + } + + memberRows, err := s.pool.Query(ctx, + `SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[])`, + chatIDs, + ) + if err != nil { + return nil, nil, fmt.Errorf("query members: %w", err) + } + defer memberRows.Close() + + membersMap := make(map[string][]string) + for memberRows.Next() { + var chatID, memberID string + if err := memberRows.Scan(&chatID, &memberID); err != nil { + return nil, nil, fmt.Errorf("scan member: %w", err) + } + membersMap[chatID] = append(membersMap[chatID], memberID) + } + + for _, c := range chats { + if members, ok := membersMap[c.ID]; ok { + c.MemberIDs = members + } + } + } + + var nextCursor *string + if hasMore && len(chats) > 0 { + lastID := chats[len(chats)-1].ID + nextCursor = &lastID + } + + return chats, nextCursor, nil +} + +func (s *PostgresStore) AddMessage(ctx context.Context, chatID, senderID, text string) (*model.Message, error) { + var isMember bool + err := s.pool.QueryRow(ctx, + `SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`, + chatID, senderID, + ).Scan(&isMember) + if err != nil { + return nil, fmt.Errorf("check membership: %w", err) + } + if !isMember { + return nil, ErrNotFound + } + + var msg model.Message + query := ` + INSERT INTO messages (chat_id, sender_id, text) + VALUES ($1, $2, $3) + RETURNING id, chat_id, sender_id, text, created_at + ` + err = s.pool.QueryRow(ctx, query, chatID, senderID, text).Scan( + &msg.ID, &msg.ChatID, &msg.SenderID, &msg.Text, &msg.CreatedAt, + ) + if err != nil { + return nil, fmt.Errorf("insert message: %w", err) + } + + msg.CreatedAt = msg.CreatedAt.UTC() + return &msg, nil +} + +func (s *PostgresStore) GetMessages(ctx context.Context, chatID, userID, cursor string, limit int) ([]*model.Message, *string, error) { + var isMember bool + err := s.pool.QueryRow(ctx, + `SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`, + chatID, userID, + ).Scan(&isMember) + if err != nil { + return nil, nil, fmt.Errorf("check membership: %w", err) + } + if !isMember { + return nil, nil, ErrNotFound + } + + // Трюк limit+1: просим на один больше, чтобы понять, есть ли следующая страница + fetchLimit := limit + 1 + + var query string + var args []interface{} + + if cursor == "" { + query = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + ORDER BY created_at, id + LIMIT $2 + ` + args = []interface{}{chatID, fetchLimit} + } else { + var cursorCreatedAt time.Time + err := s.pool.QueryRow(ctx, + `SELECT created_at FROM messages WHERE id = $1 AND chat_id = $2`, + cursor, chatID, + ).Scan(&cursorCreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil, ErrInvalidRequest + } + return nil, nil, fmt.Errorf("get cursor: %w", err) + } + + query = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 AND (created_at, id) > ($2, $3) + ORDER BY created_at, id + LIMIT $4 + ` + args = []interface{}{chatID, cursorCreatedAt, cursor, fetchLimit} + } + + rows, err := s.pool.Query(ctx, query, args...) + if err != nil { + return nil, nil, fmt.Errorf("query messages: %w", err) + } + defer rows.Close() + + messages := make([]*model.Message, 0) + for rows.Next() { + var msg model.Message + if err := rows.Scan(&msg.ID, &msg.ChatID, &msg.SenderID, &msg.Text, &msg.CreatedAt); err != nil { + return nil, nil, fmt.Errorf("scan message: %w", err) + } + msg.CreatedAt = msg.CreatedAt.UTC() + messages = append(messages, &msg) + } + + // Если вернулось больше limit — впереди есть следующая страница + hasMore := len(messages) > limit + if hasMore { + messages = messages[:limit] + } + + var nextCursor *string + if hasMore && len(messages) > 0 { + lastID := messages[len(messages)-1].ID + nextCursor = &lastID + } + + return messages, nextCursor, nil +} + +func (s *PostgresStore) CreateSession(ctx context.Context, userID, tokenHash string, expiresAt time.Time) (*model.Session, error) { + var session model.Session + query := `INSERT INTO sessions (user_id, token_hash, expires_at) VALUES ($1, $2, $3) RETURNING id, user_id, token_hash, expires_at, created_at` + err := s.pool.QueryRow(ctx, query, userID, tokenHash, expiresAt).Scan( + &session.ID, &session.UserID, &session.TokenHash, &session.ExpiresAt, &session.CreatedAt, + ) + if err != nil { + return nil, fmt.Errorf("insert session: %w", err) + } + + session.ExpiresAt = session.ExpiresAt.UTC() + session.CreatedAt = session.CreatedAt.UTC() + return &session, nil +} + +func (s *PostgresStore) GetSession(ctx context.Context, tokenHash string) (*model.Session, error) { + var session model.Session + query := `SELECT id, user_id, token_hash, expires_at, created_at FROM sessions WHERE token_hash = $1 AND expires_at > NOW()` + err := s.pool.QueryRow(ctx, query, tokenHash).Scan( + &session.ID, &session.UserID, &session.TokenHash, &session.ExpiresAt, &session.CreatedAt, + ) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, ErrNotFound + } + return nil, fmt.Errorf("get session: %w", err) + } + + session.ExpiresAt = session.ExpiresAt.UTC() + session.CreatedAt = session.CreatedAt.UTC() + return &session, nil +} + +func (s *PostgresStore) DeleteSession(ctx context.Context, tokenHash string) error { + _, err := s.pool.Exec(ctx, `DELETE FROM sessions WHERE token_hash = $1`, tokenHash) + if err != nil { + return fmt.Errorf("delete session: %w", err) + } + return nil +} + +func isUniqueViolation(err error) bool { + return err != nil && (contains(err.Error(), "23505") || contains(err.Error(), "duplicate key")) +} + +func contains(s, substr string) bool { + return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsHelper(s, substr)) +} + +func containsHelper(s, substr string) bool { + for i := 0; i <= len(s)-len(substr); i++ { + if s[i:i+len(substr)] == substr { + return true + } + } + return false +} diff --git a/student-tests/run-test.py b/student-tests/run-test.py new file mode 100755 index 00000000..c8c39f0d --- /dev/null +++ b/student-tests/run-test.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +"""Student tests lab2. Запуск: python3 student-tests/run-test.py [--base-url URL]""" +import argparse +import base64 +import json +import sys +import urllib.error +import urllib.request +import uuid + +BASE = "http://localhost:8080" +FAILURES = [] + +def req(method, path, body=None, raw=None, token=None, ctype="application/json"): + headers, data = {}, None + if raw is not None: + data, headers["Content-Type"] = raw.encode("utf-8"), ctype + elif body is not None: + data, headers["Content-Type"] = json.dumps(body, ensure_ascii=False).encode("utf-8"), ctype + + if token: + if token.startswith("Basic "): + headers["Authorization"] = token + else: + headers["Authorization"] = f"Bearer {token}" + + r = urllib.request.Request(BASE + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(r, timeout=30) as resp: + payload = resp.read().decode("utf-8") + return resp.status, dict(resp.headers), (json.loads(payload) if payload else None) + except urllib.error.HTTPError as e: + payload = e.read().decode("utf-8") + try: + return e.code, dict(e.headers), json.loads(payload) + except ValueError: + return e.code, dict(e.headers), None + +def check(name, cond, detail=""): + if not cond: + FAILURES.append(name) + print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f" -- {detail}" if not cond and detail else "")) + +def register_user(username, display_name, password): + st, _, body = req("POST", "/api/v1/users", {"username": username, "display_name": display_name, "password": password}) + assert st == 201, f"cannot create user: {st} {body}" + return body + +def login(username, password): + creds = base64.b64encode(f"{username}:{password}".encode()).decode() + st, _, body = req("POST", "/api/v1/auth/sessions", token=f"Basic {creds}") + assert st == 201, f"cannot login: {st} {body}" + return body # Возвращаем весь словарь ответа + +def main(): + global BASE + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + BASE = ap.parse_args().base_url.rstrip("/") + + # Health checks + st, hdr, body = req("GET", "/health/live") + check("health live 200", st == 200 and body == {"status": "ok"}) + check("X-Request-Id present", bool(hdr.get("X-Request-Id"))) + + # Validation tests + st, _, body = req("POST", "/api/v1/users", raw='{"username": "abc",') + check("malformed JSON -> 400", st == 400 and body["error"]["code"] == "invalid_request") + + st, _, _ = req("POST", "/api/v1/users", {"username": "BadName", "display_name": "x", "password": "validpassword123"}) + check("username pattern -> 400", st == 400) + + # Registration & Login + pwd = "SecurePassword123!" + alice = register_user("alice" + uuid.uuid4().hex[:6], "Алиса", pwd) + bob = register_user("bob" + uuid.uuid4().hex[:6], "Боб", pwd) + + st, _, body = req("POST", "/api/v1/users", {"username": alice["username"], "display_name": "dup", "password": pwd}) + check("duplicate username -> 409", st == 409 and body["error"]["code"] == "conflict") + + # ИСПРАВЛЕНО: Достаем токен из словаря ответа + alice_login_resp = login(alice["username"], pwd) + alice_token = alice_login_resp["token"] + check("login returns token", "token" in alice_login_resp and "user" in alice_login_resp) + + # Auth checks + st, _, body = req("GET", "/api/v1/users/me") + check("no token -> 401", st == 401 and body["error"]["code"] == "unauthorized") + + st, _, body = req("GET", "/api/v1/users/me", token="invalid_token") + check("invalid token -> 401", st == 401) + + # Chat & Messages + st, _, chat = req("POST", "/api/v1/chats", {"title": "Чат", "member_ids": [alice["id"], bob["id"]]}, token=alice_token) + check("create chat 201", st == 201) + + st, _, body = req("POST", f"/api/v1/chats/{chat['id']}/messages", {"text": "Привет"}, token=alice_token) + check("send message 201", st == 201 and body["text"] == "Привет") + + st, _, body = req("GET", f"/api/v1/chats/{chat['id']}/messages?limit=10", token=alice_token) + check("get messages 200", st == 200 and len(body["items"]) == 1) + + # Outsider check + eve = register_user("eve" + uuid.uuid4().hex[:6], "Ева", pwd) + eve_login_resp = login(eve["username"], pwd) + eve_token = eve_login_resp["token"] # ИСПРАВЛЕНО + + st, _, body = req("GET", f"/api/v1/chats/{chat['id']}", token=eve_token) + check("outsider GET chat -> 404", st == 404 and body["error"]["code"] == "not_found") + + # Logout (Путь согласно openapi.json: /auth/sessions/current) + st, _, _ = req("DELETE", "/api/v1/auth/sessions/current", token=alice_token) + check("logout 204", st == 204) + + st, _, body = req("GET", "/api/v1/users/me", token=alice_token) + check("token revoked -> 401", st == 401) + + print() + if FAILURES: + print(f"FAILED {len(FAILURES)}: {FAILURES}") + sys.exit(1) + print("ALL STUDENT TESTS PASSED") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/tests/resilience.py b/tests/resilience.py index f3fa700a..5ad2e365 100644 --- a/tests/resilience.py +++ b/tests/resilience.py @@ -99,7 +99,7 @@ def main(): check(proc.poll()==0,'stop-one hook did not finish successfully') check(first_recovery is not None and first_recovery<=10,'writes did not recover within 10 seconds from hook start') check(len(after_instances)>=5,'too few successful writes after stop') - check(target not in after_instances[-5:],'target replica still serves requests; hook must leave it stopped') + check(target not in after_instances[-5:],'target replica still server requests; hook must leave it stopped') print(json.dumps({'observed_instances_before':len(observed),'successful_writes':len(successes),'failed_attempts':failures,'first_recovery_seconds':round(first_recovery,3)},ensure_ascii=False)) # Existing token, no re-login. Read all confirmations and reject duplicates. messages = history(c,bob,chat)