ЛР 2 - БВТ2304 - Тюрина - на 4 #49

Closed
Rakshasa wants to merge 1 commits from Rakshasa/mtusi2026lab2-fork:solution/BVT2304-Tyurina into master
16 changed files with 2376 additions and 25 deletions
+27
View File
@@ -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"]
+290 -24
View File
@@ -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 <token>`; `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 <URL_ФОСКА>
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 — не сдан (план в Приложении).
+54
View File
@@ -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:
+73
View File
@@ -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 <<EOF
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '$CHAT_ID'
ORDER BY created_at, id
LIMIT 50;
EOF
echo ""
echo " EXPLAIN (ANALYZE, BUFFERS) для пагинации с курсором "
CURSOR=$(docker compose exec -T postgres psql -U lab2 -d lab2 -tAc \
"SELECT id FROM messages WHERE chat_id = '$CHAT_ID' ORDER BY created_at, id LIMIT 1 OFFSET 50;")
CURSOR_CREATED=$(docker compose exec -T postgres psql -U lab2 -d lab2 -tAc \
"SELECT created_at FROM messages WHERE id = '$CURSOR';")
docker compose exec -T postgres psql -U lab2 -d lab2 <<EOF
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '$CHAT_ID' AND (created_at, id) > ('$CURSOR_CREATED', '$CURSOR')
ORDER BY created_at, id
LIMIT 50;
EOF
echo ""
echo "Benchmark completed"
+127
View File
@@ -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
+18
View File
@@ -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
+319
View File
@@ -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 <URL_ФОСКА>
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).»
+141
View File
@@ -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")
}
+46
View File
@@ -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)
}
+434
View File
@@ -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"})
}
+34
View File
@@ -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"`
}
+85
View File
@@ -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
}
@@ -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);
+555
View File
@@ -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
}
+125
View File
@@ -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()
+1 -1
View File
@@ -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)