Лабораторная №2 - Соколов Илья Сергеевич - БВТ2302 - оценка 3 #41
+11
-1
@@ -1,5 +1,6 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
# scripts/init-secrets.(ps1|sh) делает это автоматически, если .env ещё нет.
|
||||
# Все переменные необязательны: у каждой есть значение по умолчанию в compose.yaml.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
@@ -9,3 +10,12 @@ DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
|
||||
# --- добавлено в lab2 ---
|
||||
# Порт на 127.0.0.1 хоста, на котором доступен API.
|
||||
PUBLISHED_PORT=8080
|
||||
# Имя БД и пользователя PostgreSQL (пароль — в secrets/postgres_password, не здесь).
|
||||
POSTGRES_DB=messenger
|
||||
POSTGRES_USER=messenger
|
||||
# Максимум соединений пула API с PostgreSQL.
|
||||
DB_MAX_CONNS=10
|
||||
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
# syntax=docker/dockerfile:1
|
||||
# Сборка из исходников; образ-сервер преподавателя не используется.
|
||||
FROM golang:1.23.8-bookworm AS build
|
||||
|
||||
WORKDIR /src
|
||||
# Сначала манифесты зависимостей: слой кэшируется, пока go.mod/go.sum не менялись.
|
||||
COPY go.mod go.sum ./
|
||||
RUN go mod download && go mod verify
|
||||
COPY *.go ./
|
||||
COPY migrations ./migrations
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger .
|
||||
|
||||
# Пустой runtime-образ: один статический бинарник, нет shell и пакетного менеджера.
|
||||
FROM scratch
|
||||
COPY --from=build /out/messenger /messenger
|
||||
|
||||
ENV APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080
|
||||
EXPOSE 8080
|
||||
# Не root: числовой UID достаточен, /etc/passwd в scratch не нужен.
|
||||
USER 65532:65532
|
||||
# В scratch нет curl, поэтому проверку выполняет сам бинарник (GET /health/ready).
|
||||
HEALTHCHECK --interval=10s --timeout=4s --start-period=5s --retries=3 CMD ["/messenger", "healthcheck"]
|
||||
# PID 1 — сам процесс; он корректно завершается по SIGTERM (graceful shutdown).
|
||||
ENTRYPOINT ["/messenger"]
|
||||
CMD ["serve"]
|
||||
@@ -1,37 +1,193 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Исполнитель сдачи, группа: **Соколов Илья Сергеевич, БВТ2302**
|
||||
|
||||
- Происхождение реализации: полученный архив `lab2-sokolov.zip`; в исходном отчёте указан Соколов Илья Сергеевич, БВТ2302. Проверки Windows выполнены на основе этого архива.
|
||||
|
||||
- Целевая оценка; выбранный трек 5, если нужен: **3 — работающий минимум**
|
||||
|
||||
- Git: форк [`Sokolov-Ilya/mtusi2026lab2`](https://gitea.privcloud.tech/Sokolov-Ilya/mtusi2026lab2), ветка `solution/sokolov-bvt-2302`; коммиты реализации `e83ed9e` и обновления отчёта `e59fc11` (опубликованы).
|
||||
|
||||
- Pull Request: **[#41 — Лабораторная №2, Соколов Илья Сергеевич, БВТ2302, оценка 3](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/41)**. Направление: `Sokolov-Ilya/mtusi2026lab2:solution/sokolov-bvt-2302` → `mtusi2026/mtusi2026lab2:master`. PR создан и открыт для проверки; целевая оценка — **3**.
|
||||
|
||||
- Использованные источники, библиотеки и помощь ИИ: Go 1.23 (`net/http`, `encoding/json`), [pgx v5.7.2](https://github.com/jackc/pgx) (драйвер и пул PostgreSQL), [alexedwards/argon2id v1.0.0](https://github.com/alexedwards/argon2id) поверх `golang.org/x/crypto/argon2` (Argon2id), PostgreSQL 16, Docker Compose. В исходном отчёте автор реализации указал перенос кода lab1 и при переносе на PostgreSQL, написании миграций, Compose и тестов. При адаптации и проверке на Windows использовался ChatGPT для диагностики Docker, кодировки и порядка проверки. Перед сдачей уточните, какие части реализации и отчёта выполнены лично, и укажите действительное авторство.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Версии: образы `golang:1.23.8-bookworm` (сборка), `scratch` (runtime, один статический бинарник), `postgres:16.9-bookworm`. Нужен Docker Desktop с Compose v2; Go локально не нужен. Python 3.9+ — только для публичных тестов.
|
||||
|
||||
PowerShell (Windows):
|
||||
|
||||
```powershell
|
||||
|
||||
# 1. Локальные секреты и .env (повторный запуск ничего не перезаписывает)
|
||||
|
||||
powershell -ExecutionPolicy Bypass -File scripts\init-secrets.ps1
|
||||
|
||||
# 2. Проверка конфигурации, сборка и запуск: postgres -> migrate (одноразово) -> api
|
||||
|
||||
docker compose --env-file .env config --quiet
|
||||
|
||||
docker compose --env-file .env up -d --build
|
||||
|
||||
# 3. Дождаться готовности (ожидаем {"status":"ok"})
|
||||
|
||||
curl.exe http://localhost:8080/health/ready
|
||||
|
||||
# 4. Публичные проверки
|
||||
|
||||
$env:PYTHONUTF8="1"
|
||||
|
||||
python tests\smoke.py --base-url http://localhost:8080
|
||||
|
||||
python -X utf8 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
|
||||
|
||||
```
|
||||
|
||||
Linux/macOS/Git Bash: `sh scripts/init-secrets.sh`, `make up`, `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`.
|
||||
|
||||
Действия оператора: только шаг 1 (создаёт `secrets/postgres_password`, `secrets/database_url` и `.env`; они в `.gitignore`). Миграции выполняет сервис `migrate` автоматически; вручную: `docker compose run --rm migrate`.
|
||||
|
||||
- **Безопасная остановка** (данные сохраняются): `docker compose down` или `docker compose stop`.
|
||||
|
||||
- **Намеренное удаление учебных данных**: `docker compose down -v` (удаляет volume `pgdata` вместе с данными; `secrets\\` можно оставить — прежний пароль просто станет паролем новой БД).
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```text
|
||||
|
||||
Клиент ──HTTP 127.0.0.1:8080──► api (Go, scratch, не root, read_only)
|
||||
|
||||
│ сеть backend (internal: нет выхода наружу)
|
||||
|
||||
▼
|
||||
|
||||
postgres 16 ── volume pgdata (named)
|
||||
|
||||
migrate (одноразовый контейнер того же образа) ──► postgres
|
||||
|
||||
```
|
||||
|
||||
| Роль | Service | Образ/версия | Health/readiness | Volume | Сеть/порт | Credentials |
|
||||
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
|
||||
| api | `api` | сборка из `Dockerfile` (Go 1.23.8 → scratch) | `HEALTHCHECK` → `/messenger healthcheck` → `GET /health/ready` | — (состояния нет) | `frontend`+`backend`; `127.0.0.1:8080→8080` | `DATABASE_URL_FILE=/run/secrets/database_url` |
|
||||
|
||||
| postgres | `postgres` | `postgres:16.9-bookworm` | `pg_isready` каждые 5 с | `pgdata:/var/lib/postgresql/data` | только `backend`, порт наружу не публикуется | `POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password` |
|
||||
|
||||
| миграции | `migrate` | тот же образ `mtusi-messenger:lab2`, команда `migrate` | завершается кодом 0 | — | `backend` | `database_url` |
|
||||
|
||||
**Источник истины — PostgreSQL**: пользователи, чаты, участники, сообщения и сессии. Процесс API не хранит состояния: после его перезапуска ничего не теряется.
|
||||
|
||||
**Схема** (`migrations/001_init.sql`, `002_sessions.sql`; описана до запросов, в комментариях — транзакционные границы):
|
||||
|
||||
- `users(id uuid PK, username UNIQUE + CHECK ^[a-z0-9\_]{3,32}$, display_name CHECK 1..100, password_hash, created_at)`;
|
||||
|
||||
- `chats(id PK, title, created_by FK→users, created_at)`, индекс `(created_at, id)`;
|
||||
|
||||
- `chat_members(chat_id FK→chats ON DELETE CASCADE, user_id FK→users, PK(chat_id, user_id))`, индекс `(user_id, chat_id)` для «чатов пользователя»;
|
||||
|
||||
- `messages(id PK, chat_id FK, sender_id FK, text CHECK 1..4000, created_at)`, индекс `(chat_id, created_at, id)` под keyset-историю;
|
||||
|
||||
- `sessions(token_hash bytea PK = SHA-256 токена, user_id FK ON DELETE CASCADE, created_at, expires_at, revoked_at)`.
|
||||
|
||||
**Транзакционные границы.** Регистрация — один `INSERT`; уникальность username решает сама БД (`UNIQUE`), поэтому две одновременные регистрации дают одну `201` и `409`, а не проверку «сначала SELECT». **Создание чата — составная операция в одной транзакции**: `INSERT chats` + `INSERT chat_members` всех участников; несуществующий участник нарушает FK, транзакция откатывается целиком, «половинчатого» чата не остаётся. Отправка сообщения — один `INSERT`; клиент получает `201` только после `COMMIT`.
|
||||
|
||||
**Что подтверждает COMMIT.** PostgreSQL в `compose.yaml` запущен с явными `fsync=on`, `synchronous_commit=on`, `full_page_writes=on`: ответ `201` отправляется после того, как запись WAL сброшена на диск. При `synchronous_commit=off` или `fsync=off` подтверждённое сообщение могло бы потеряться при аварии.
|
||||
|
||||
**Аутентификация.** `POST /api/v1/auth/sessions` — единственное место, где принимается `Authorization: Basic` (base64 от `username:password`, UTF-8, двоеточие в пароле допустимо). Пароль хранится как **Argon2id** (m=64 MiB, t=3, p=2, соль 16 байт; PHC-строка), сравнение за постоянное время; для несуществующего пользователя выполняется «пустышечное» хеширование, поэтому ответ и время одинаковы. Токен — 32 байта `crypto/rand` (256 бит, 43 символа base64url), в БД только его SHA-256. Срок жизни — `expires_at`, считается по часам PostgreSQL от момента входа и не продлевается рестартом. Все остальные endpoint принимают только `Bearer`; `X-User-Id` игнорируется, Basic на них даёт `401` с `WWW-Authenticate: Bearer realm="messenger"`. Logout (`DELETE /auth/sessions/current`) проставляет `revoked_at`, повтор — `401`.
|
||||
|
||||
**Аутентификация ≠ доступ к чату.** Сначала проверяется сессия (иначе `401`), затем членство в конкретном чате; чужой и несуществующий чат одинаково дают `404`, так что существование чужого чата не раскрывается.
|
||||
|
||||
**Что перенесено из lab1 и что изменено.** Перенесены: формат ошибок и `X-Request-Id`, строгая валидация JSON (лишние поля → 400), правила для username/display_name/title/text, keyset-пагинация с курсором, привязанным к ресурсу (курсор другого чата → 400), маршрутизация. Изменено согласно `COURSE.md` (переход 1 → 2): `password` при регистрации; Basic только для создания сессии; Bearer вместо `X-User-Id`; in-memory `Store` заменён PostgreSQL; добавлены логин/logout, миграции, readiness с проверкой БД и схемы. Дополнительно: проверка доступа к чату теперь идёт **до** разбора тела запроса, а ошибки зависимостей — `503` без деталей.
|
||||
|
||||
**Соответствие `.env.example`.** `APP_HOST`, `APP_PORT`, `SESSION_TTL_SECONDS` (по умолчанию 3600), `SESSION_STORE` (на 3 поддерживается только `postgres`, иное значение — ошибка запуска), `DATABASE_URL_FILE` читаются приложением; `APP_ENV` передаётся, но не влияет на поведение; `CACHE_URL_FILE` не используется (Redis/Valkey нужен только на 4). Добавлены `PUBLISHED_PORT`, `POSTGRES_DB`, `POSTGRES_USER`, `DB_MAX_CONNS` (compose).
|
||||
|
||||
**Readiness.** `/health/live` — только жив ли процесс. `/health/ready` — `200`, если PostgreSQL отвечает и применены все миграции; иначе `503` в общем формате. Недоступность БД не валит процесс: API остаётся жив и сам восстанавливается, когда БД вернулась.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
В исходном архиве были приведены результаты проверки на Linux **без Docker** (PostgreSQL 16.2, Go 1.23.8); их происхождение сохранено отдельно. **Дополнительно 12–13 октября 2026 года проверен реальный запуск на Windows с Docker Desktop 4.78.0, Docker Engine 29.5.3, PostgreSQL 16.9-bookworm и образом `mtusi-messenger:lab2`.** Полные результаты и временные отметки — [evidence/lab2-verification.md](evidence/lab2-verification.md), раздел 10.
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
|
||||
| --- | --- | --- | --- |
|
||||
|
||||
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` (подтверждено также в Windows Docker) | evidence/lab2-verification.md |
|
||||
|
||||
| Данные и сессия переживают рестарт API и PostgreSQL | `make test-persistence ACTION_SCRIPT=\<hook>` | `PASS: persistence preserved confirmed data and existing session`; в Windows Docker изменился `StartedAt` и PostgreSQL, и API (см. раздел 10 evidence) | evidence/lab2-verification.md |
|
||||
|
||||
| PK/FK, UNIQUE(username), миграции с нуля | `messenger migrate` на пустой БД, `\dt`, `schema_migrations` | 2 миграции применены, 6 таблиц | evidence/lab2-verification.md |
|
||||
|
||||
| Повторный запуск миграций без дублей | `messenger migrate` ×2 + Go-тест `TestMigrationsAreIdempotent` | второй запуск: `0 new, 2 total`; число строк users/schema_migrations не меняется | evidence/lab2-verification.md |
|
||||
|
||||
| Атомарное создание чата | Go-тест `TestCreateChatIsAtomic`; `extra_checks.py` | неизвестный участник → `400`, `chats`/`chat_members` без остатков | evidence/lab2-verification.md |
|
||||
|
||||
| Basic только на `POST /auth/sessions`, Bearer везде, `X-User-Id` не работает | публичный smoke + `TestSessionLifecycle` | Basic на `/users/me` → 401 Bearer; `X-User-Id` → 401 | evidence/lab2-verification.md |
|
||||
|
||||
| Срок жизни и отзыв сессии | `extra_checks.py --expiry` (TTL=2 с), logout в smoke | после TTL → 401; logout → 204, затем 401, повторный logout → 401 | evidence/lab2-verification.md |
|
||||
|
||||
| Пароли хешируются KDF | чтение кода `auth.go`, `SELECT password_hash` | PHC `$argon2id$v=19$m=65536,t=3,p=2$…` | evidence/lab2-verification.md |
|
||||
|
||||
| Secrets/volumes не в Git | временный `git init` + `git add -A` | `secrets/`, `.env`, `pgdata/`, `volumes/` не попали в индекс | evidence/lab2-verification.md |
|
||||
|
||||
| Поведение при недоступной БД (бонус к уровню 3) | остановка PostgreSQL | `/health/ready` → 503, защищённые запросы → 503, `/health/live` → 200, после старта БД API восстановился сам | evidence/lab2-verification.md |
|
||||
|
||||
| Все пункты уровня 4 / трек 5 | — | **не заявляются** | — |
|
||||
|
||||
Ключевые команды из фактически выполненной проверки Docker на Windows (результаты приведены в evidence):
|
||||
|
||||
```powershell
|
||||
|
||||
docker compose --env-file .env ps -a
|
||||
|
||||
docker inspect -f "{{.Name}} started={{.State.StartedAt}}" mtusi-lab2-postgres-1 mtusi-lab2-api-1 # ДО рестарта
|
||||
|
||||
python -X utf8 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
|
||||
|
||||
docker inspect -f "{{.Name}} started={{.State.StartedAt}}" mtusi-lab2-postgres-1 mtusi-lab2-api-1 # ПОСЛЕ: время запуска должно измениться
|
||||
|
||||
docker compose --env-file .env run --rm migrate
|
||||
|
||||
docker compose --env-file .env run --rm migrate # повторный запуск миграций
|
||||
|
||||
# истечение сессии на отдельном коротком TTL, затем вернуть обычный
|
||||
|
||||
$env:SESSION_TTL_SECONDS="2"; docker compose --env-file .env up -d --force-recreate api
|
||||
|
||||
python -X utf8 student-tests\extra_checks.py --expiry
|
||||
|
||||
Remove-Item Env:SESSION_TTL_SECONDS; docker compose --env-file .env up -d --force-recreate api
|
||||
|
||||
```
|
||||
|
||||
Собственные тесты: `go test ./...` (юнит-тесты без БД; интеграционные включаются переменной `TEST_DATABASE_URL`) и `student-tests/extra_checks.py` (против запущенного стенда, работает на Windows без Go).
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Нагрузочный эксперимент дополнительно проведён 12 октября 2026 года на Windows: 10 секунд, конкурентность 2, 2348 успешных запросов, 0 ошибок, 234,074 успешных запроса/с, p95=31 мс, p99=32 мс. Результат сохранён в `evidence/load-demo.json`. Также проведён эксперимент отказа/перезапуска.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
|
||||
| Перезапуск API и PostgreSQL (`fast` shutdown → старт), volume сохранён; токен только в памяти теста | те же пользователь, чат, сообщение; прежний токен действует | `PASS` persistence (в исходном Linux-тесте и отдельно в Docker на Windows) | тест подтвердил сохранность данных и токена; измерение времени восстановления отдельно не выполнялось |
|
||||
|
||||
| Остановка PostgreSQL при работающем API | `/health/ready` → 503, запросы → 503 без деталей, процесс жив | как ожидалось; `live` = 200; анонимный запрос не принят как доверенный | после старта БД API ответил `200` на ближайшей проверке без рестарта |
|
||||
|
||||
| 12 параллельных регистраций одного username | одна `201`, остальные `409` | 1×201 + 11×409; в БД одна строка | — |
|
||||
|
||||
| Docker-вариант перезапуска (`restart.cmd`) | сохранить подтверждённые данные и сессию, перезапустить оба контейнера | `PASS`; `StartedAt` PostgreSQL и API изменился; данные и прежняя сессия сохранились | отметки времени в `evidence/lab2-verification.md`, раздел 10 |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Выдерживается:** перезапуск API и PostgreSQL с сохранением volume; потеря соединений с БД (пул проверяет соединения перед выдачей, после рестарта БД они пересоздаются); одновременная регистрация одного username.
|
||||
|
||||
- **Не выдерживается / не реализовано:** потеря самого Docker-host или volume (один экземпляр PostgreSQL, нет репликации и бэкапов); один экземпляр API (балансировка — lab3); Redis/Valkey и всё остальное из уровней 4–5 не реализовано. Сессии хранятся только в PostgreSQL (`SESSION_STORE=postgres`), поэтому их сохранность равна сохранности БД.
|
||||
|
||||
- **Учебные упрощения:** HTTP без TLS (допустимо для локального стенда с синтетическими данными: Basic — кодирование, не шифрование; для удалённой демонстрации нужен TLS); файлы секретов читаются всеми на хосте (`chmod 644`), чтобы их мог прочитать пользователь контейнера; ограничения частоты запросов (429) нет; нет автоматической чистки сессий по расписанию — устаревшие строки удаляются при входе.
|
||||
|
||||
- **Семантика истории при конкурентных вставках:** порядок задаёт `(created_at, id)`, время назначает PostgreSQL (`clock_timestamp()`, микросекунды). Сообщение, зафиксированное позже, но с более ранним временем, чем уже выданный курсор, на уже прочитанную страницу не попадёт; повторов на неизменной истории нет. Snapshot-изоляции между HTTP-запросами нет, как и разрешает контракт.
|
||||
|
||||
- **Подтверждено на Windows:** `scripts/init-secrets.ps1`, запуск `docker compose --env-file .env up -d --build`, `scripts/restart.cmd` в persistence-тесте, успешное состояние `api`/`postgres` и завершение `migrate`. Команда `docker compose config --quiet` отдельно в представленном журнале не зафиксирована; воспроизводимость подтверждена успешным запуском Compose.
|
||||
|
||||
+307
@@ -0,0 +1,307 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Тесты без БД всегда выполняются; тесты с БД — только если задан TEST_DATABASE_URL
|
||||
// (пустая тестовая БД, например postgres://messenger@127.0.0.1:55432/messenger_test).
|
||||
|
||||
func TestCursorIsBoundToResource(t *testing.T) {
|
||||
now := time.Now().UTC().Truncate(time.Microsecond)
|
||||
c := encodeCursor("messages", "chat-a", now, newUUID())
|
||||
if _, _, err := decodeCursor(c, "messages", "chat-a"); err != nil {
|
||||
t.Fatalf("own cursor rejected: %v", err.message)
|
||||
}
|
||||
if _, _, err := decodeCursor(c, "messages", "chat-b"); err == nil || err.status != 400 {
|
||||
t.Fatal("cursor of another chat must be rejected with 400")
|
||||
}
|
||||
if _, _, err := decodeCursor(c, "chats", "chat-a"); err == nil {
|
||||
t.Fatal("cursor of another list kind must be rejected")
|
||||
}
|
||||
if _, _, err := decodeCursor("not-a-cursor", "messages", "chat-a"); err == nil {
|
||||
t.Fatal("garbage cursor must be rejected")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBasicParsing(t *testing.T) {
|
||||
mk := func(raw string) *http.Request {
|
||||
r := httptest.NewRequest("POST", "/", nil)
|
||||
r.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(raw)))
|
||||
return r
|
||||
}
|
||||
u, p, ok := parseBasic(mk("alice:pa:ss:wörd-ü"))
|
||||
if !ok || u != "alice" || p != "pa:ss:wörd-ü" {
|
||||
t.Fatalf("colon in password must be kept, got %q %q %v", u, p, ok)
|
||||
}
|
||||
if _, _, ok := parseBasic(mk("no-colon")); ok {
|
||||
t.Fatal("credentials without colon must be rejected")
|
||||
}
|
||||
r := httptest.NewRequest("POST", "/", nil)
|
||||
r.Header.Set("Authorization", "Basic !!!not-base64")
|
||||
if _, _, ok := parseBasic(r); ok {
|
||||
t.Fatal("invalid base64 must be rejected")
|
||||
}
|
||||
b := httptest.NewRequest("GET", "/", nil)
|
||||
b.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("a:b")))
|
||||
if _, ok := bearerToken(b); ok {
|
||||
t.Fatal("Basic must not be accepted as Bearer")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTokenAndPasswordHash(t *testing.T) {
|
||||
token, hash := newToken()
|
||||
if len(token) != 43 || len(hash) != 32 {
|
||||
t.Fatalf("token must carry 256 bits (43 base64url chars), got %d", len(token))
|
||||
}
|
||||
if other, _ := newToken(); other == token {
|
||||
t.Fatal("tokens must be unique")
|
||||
}
|
||||
h := newHasher(1)
|
||||
hashed, err := h.hash(context.Background(), "correct horse battery")
|
||||
if err != nil || len(hashed) < 40 || hashed[:10] != "$argon2id$" {
|
||||
t.Fatalf("expected a PHC argon2id hash, got %q (%v)", hashed, err)
|
||||
}
|
||||
if ok, _ := h.verify(context.Background(), "correct horse battery", hashed); !ok {
|
||||
t.Fatal("correct password must verify")
|
||||
}
|
||||
if ok, _ := h.verify(context.Background(), "wrong horse battery!", hashed); ok {
|
||||
t.Fatal("wrong password must not verify")
|
||||
}
|
||||
}
|
||||
|
||||
// ---- тесты с PostgreSQL ----
|
||||
|
||||
type env struct {
|
||||
srv *httptest.Server
|
||||
store *Store
|
||||
url string
|
||||
}
|
||||
|
||||
func setup(t *testing.T, ttl int) *env {
|
||||
t.Helper()
|
||||
url := os.Getenv("TEST_DATABASE_URL")
|
||||
if url == "" {
|
||||
t.Skip("TEST_DATABASE_URL is not set")
|
||||
}
|
||||
ctx := context.Background()
|
||||
if err := runMigrations(ctx, url); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
pool, err := newPool(ctx, url, 10)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(pool.Close)
|
||||
store := &Store{pool: pool}
|
||||
api := &API{store: store, hasher: newHasher(4), ttlSecs: ttl, reqLimit: 8 * time.Second}
|
||||
srv := httptest.NewServer(api)
|
||||
t.Cleanup(srv.Close)
|
||||
return &env{srv: srv, store: store, url: url}
|
||||
}
|
||||
|
||||
func (e *env) do(t *testing.T, method, path string, body any, headers map[string]string) (int, map[string]any, http.Header) {
|
||||
t.Helper()
|
||||
var rd *bytes.Reader
|
||||
if body != nil {
|
||||
raw, _ := json.Marshal(body)
|
||||
rd = bytes.NewReader(raw)
|
||||
} else {
|
||||
rd = bytes.NewReader(nil)
|
||||
}
|
||||
req, _ := http.NewRequest(method, e.srv.URL+path, rd)
|
||||
if body != nil {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
for k, v := range headers {
|
||||
req.Header.Set(k, v)
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
var out map[string]any
|
||||
_ = json.NewDecoder(resp.Body).Decode(&out)
|
||||
return resp.StatusCode, out, resp.Header
|
||||
}
|
||||
|
||||
func basic(user, pass string) map[string]string {
|
||||
return map[string]string{"Authorization": "Basic " + base64.StdEncoding.EncodeToString([]byte(user+":"+pass))}
|
||||
}
|
||||
|
||||
func bearer(token string) map[string]string {
|
||||
return map[string]string{"Authorization": "Bearer " + token}
|
||||
}
|
||||
|
||||
func (e *env) register(t *testing.T, name string) (id, pass string) {
|
||||
t.Helper()
|
||||
pass = "Passw0rd-" + newUUID()
|
||||
status, out, _ := e.do(t, "POST", "/api/v1/users", map[string]any{"username": name, "display_name": "Тест", "password": pass}, nil)
|
||||
if status != 201 {
|
||||
t.Fatalf("register %s: %d %v", name, status, out)
|
||||
}
|
||||
if _, leaked := out["password"]; leaked {
|
||||
t.Fatal("password must never be returned")
|
||||
}
|
||||
return out["id"].(string), pass
|
||||
}
|
||||
|
||||
func (e *env) login(t *testing.T, name, pass string) string {
|
||||
t.Helper()
|
||||
status, out, _ := e.do(t, "POST", "/api/v1/auth/sessions", nil, basic(name, pass))
|
||||
if status != 201 {
|
||||
t.Fatalf("login: %d %v", status, out)
|
||||
}
|
||||
return out["token"].(string)
|
||||
}
|
||||
|
||||
func uname() string { return "t_" + strings.ReplaceAll(newUUID(), "-", "")[:12] }
|
||||
|
||||
func TestRegistrationRaceYieldsOneUser(t *testing.T) {
|
||||
e := setup(t, 3600)
|
||||
name := uname()
|
||||
const workers = 16
|
||||
var wg sync.WaitGroup
|
||||
codes := make(chan int, workers)
|
||||
for i := 0; i < workers; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
status, _, _ := e.do(t, "POST", "/api/v1/users", map[string]any{"username": name, "display_name": "Гонка", "password": "Race-password-123"}, nil)
|
||||
codes <- status
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
close(codes)
|
||||
created, conflicts := 0, 0
|
||||
for c := range codes {
|
||||
switch c {
|
||||
case 201:
|
||||
created++
|
||||
case 409:
|
||||
conflicts++
|
||||
default:
|
||||
t.Fatalf("unexpected status %d", c)
|
||||
}
|
||||
}
|
||||
if created != 1 || conflicts != workers-1 {
|
||||
t.Fatalf("expected exactly one 201 and %d×409, got %d / %d", workers-1, created, conflicts)
|
||||
}
|
||||
var n int
|
||||
if err := e.store.pool.QueryRow(context.Background(), `SELECT count(*) FROM users WHERE username = $1`, name).Scan(&n); err != nil || n != 1 {
|
||||
t.Fatalf("database must hold exactly one row, got %d (%v)", n, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateChatIsAtomic(t *testing.T) {
|
||||
e := setup(t, 3600)
|
||||
name := uname()
|
||||
id, pass := e.register(t, name)
|
||||
ctx := context.Background()
|
||||
var before int
|
||||
_ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&before)
|
||||
|
||||
// Участник-призрак: INSERT чата уже выполнен, INSERT участников падает на внешнем ключе -> откат всего.
|
||||
chat := Chat{ID: newUUID(), Title: "rollback", MemberIDs: []string{id, newUUID()}}
|
||||
if _, err := e.store.createChat(ctx, chat, id); err != errInvalidMembers {
|
||||
t.Fatalf("expected errInvalidMembers, got %v", err)
|
||||
}
|
||||
var after, members int
|
||||
_ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&after)
|
||||
_ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chat_members WHERE chat_id = $1::uuid`, chat.ID).Scan(&members)
|
||||
if after != before || members != 0 {
|
||||
t.Fatalf("partial chat left behind: chats %d->%d, members %d", before, after, members)
|
||||
}
|
||||
|
||||
// То же через HTTP: 400, а у пользователя по-прежнему нет чатов.
|
||||
token := e.login(t, name, pass)
|
||||
status, _, _ := e.do(t, "POST", "/api/v1/chats", map[string]any{"title": "x", "member_ids": []string{id, newUUID()}}, bearer(token))
|
||||
if status != 400 {
|
||||
t.Fatalf("unknown member must give 400, got %d", status)
|
||||
}
|
||||
_, list, _ := e.do(t, "GET", "/api/v1/chats", nil, bearer(token))
|
||||
if items, _ := list["items"].([]any); len(items) != 0 {
|
||||
t.Fatalf("failed creation must leave no chat, got %d", len(items))
|
||||
}
|
||||
}
|
||||
|
||||
func TestSessionLifecycle(t *testing.T) {
|
||||
e := setup(t, 1) // TTL = 1 с
|
||||
name := uname()
|
||||
id, pass := e.register(t, name)
|
||||
|
||||
// неверный пароль и неизвестный пользователь: одинаковый 401 + Basic challenge
|
||||
for _, c := range []map[string]string{basic(name, "wrong-password-xx"), basic(uname(), "whatever-password")} {
|
||||
status, _, h := e.do(t, "POST", "/api/v1/auth/sessions", nil, c)
|
||||
if status != 401 || h.Get("WWW-Authenticate") != basicChallenge {
|
||||
t.Fatalf("bad credentials: %d %q", status, h.Get("WWW-Authenticate"))
|
||||
}
|
||||
}
|
||||
token := e.login(t, name, pass)
|
||||
|
||||
status, out, _ := e.do(t, "GET", "/api/v1/users/me", nil, bearer(token))
|
||||
if status != 200 || out["id"] != id {
|
||||
t.Fatalf("fresh session must work: %d", status)
|
||||
}
|
||||
// X-User-Id не даёт доступа и не подменяет владельца; Basic на бизнес-эндпоинте — 401
|
||||
if status, _, _ := e.do(t, "GET", "/api/v1/users/me", nil, map[string]string{"X-User-Id": id}); status != 401 {
|
||||
t.Fatalf("X-User-Id alone must give 401, got %d", status)
|
||||
}
|
||||
if status, _, h := e.do(t, "GET", "/api/v1/users/me", nil, basic(name, pass)); status != 401 || h.Get("WWW-Authenticate") != bearerChallenge {
|
||||
t.Fatalf("Basic on business endpoint must give 401 Bearer, got %d", status)
|
||||
}
|
||||
|
||||
// истечение срока
|
||||
time.Sleep(1300 * time.Millisecond)
|
||||
if status, _, _ := e.do(t, "GET", "/api/v1/users/me", nil, bearer(token)); status != 401 {
|
||||
t.Fatalf("expired session must give 401, got %d", status)
|
||||
}
|
||||
|
||||
// logout (отдельный пользователь с длинным TTL)
|
||||
long := setup(t, 3600)
|
||||
n2 := uname()
|
||||
_, p2 := long.register(t, n2)
|
||||
t2 := long.login(t, n2, p2)
|
||||
if status, _, _ := long.do(t, "DELETE", "/api/v1/auth/sessions/current", nil, bearer(t2)); status != 204 {
|
||||
t.Fatalf("logout must give 204, got %d", status)
|
||||
}
|
||||
if status, _, _ := long.do(t, "GET", "/api/v1/users/me", nil, bearer(t2)); status != 401 {
|
||||
t.Fatalf("revoked token must give 401, got %d", status)
|
||||
}
|
||||
if status, _, _ := long.do(t, "DELETE", "/api/v1/auth/sessions/current", nil, bearer(t2)); status != 401 {
|
||||
t.Fatalf("repeated logout must give 401, got %d", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMigrationsAreIdempotent(t *testing.T) {
|
||||
e := setup(t, 3600)
|
||||
name := uname()
|
||||
e.register(t, name)
|
||||
count := func(table string) int {
|
||||
var n int
|
||||
if err := e.store.pool.QueryRow(context.Background(), `SELECT count(*) FROM `+table).Scan(&n); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return n
|
||||
}
|
||||
users, versions := count("users"), count("schema_migrations")
|
||||
for i := 0; i < 2; i++ {
|
||||
if err := runMigrations(context.Background(), e.url); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if count("users") != users || count("schema_migrations") != versions {
|
||||
t.Fatal("re-running migrations changed data or duplicated version records")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"net/http"
|
||||
"regexp"
|
||||
"strings"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/alexedwards/argon2id"
|
||||
)
|
||||
|
||||
// Argon2id (RFC 9106, профиль «низкая память»: t=3, m=64 MiB). Параметры хранятся внутри PHC-строки хеша,
|
||||
// поэтому их можно менять без инвалидации старых паролей.
|
||||
var argonParams = &argon2id.Params{Memory: 64 * 1024, Iterations: 3, Parallelism: 2, SaltLength: 16, KeyLength: 32}
|
||||
|
||||
var tokenPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{32,256}$`)
|
||||
|
||||
// Hasher ограничивает число одновременных хеширований: каждое занимает 64 MiB памяти.
|
||||
type Hasher struct {
|
||||
sem chan struct{}
|
||||
dummy string // хеш-«пустышка»: вход несуществующего пользователя стоит столько же времени, сколько неверный пароль
|
||||
}
|
||||
|
||||
func newHasher(concurrency int) *Hasher {
|
||||
h := &Hasher{sem: make(chan struct{}, concurrency)}
|
||||
dummy, err := argon2id.CreateHash("dummy-password-for-timing-equalization", argonParams)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
h.dummy = dummy
|
||||
return h
|
||||
}
|
||||
|
||||
func (h *Hasher) acquire(ctx context.Context) error {
|
||||
select {
|
||||
case h.sem <- struct{}{}:
|
||||
return nil
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
}
|
||||
}
|
||||
func (h *Hasher) release() { <-h.sem }
|
||||
|
||||
func (h *Hasher) hash(ctx context.Context, password string) (string, error) {
|
||||
if err := h.acquire(ctx); err != nil {
|
||||
return "", err
|
||||
}
|
||||
defer h.release()
|
||||
return argon2id.CreateHash(password, argonParams)
|
||||
}
|
||||
|
||||
func (h *Hasher) verify(ctx context.Context, password, hash string) (bool, error) {
|
||||
if err := h.acquire(ctx); err != nil {
|
||||
return false, err
|
||||
}
|
||||
defer h.release()
|
||||
return argon2id.ComparePasswordAndHash(password, hash) // сравнение за постоянное время
|
||||
}
|
||||
|
||||
// newToken: 32 байта из crypto/rand (256 бит), клиенту — base64url (43 символа), в БД — только SHA-256.
|
||||
func newToken() (token string, hash []byte) {
|
||||
raw := make([]byte, 32)
|
||||
if _, err := rand.Read(raw); err != nil {
|
||||
panic("crypto/rand failed")
|
||||
}
|
||||
token = base64.RawURLEncoding.EncodeToString(raw)
|
||||
return token, hashToken(token)
|
||||
}
|
||||
|
||||
func hashToken(token string) []byte {
|
||||
sum := sha256.Sum256([]byte(token))
|
||||
return sum[:]
|
||||
}
|
||||
|
||||
// splitAuthorization разбирает «Scheme value»; схема нечувствительна к регистру (RFC 9110).
|
||||
func splitAuthorization(r *http.Request) (scheme, value string) {
|
||||
header := r.Header.Get("Authorization")
|
||||
scheme, value, ok := strings.Cut(header, " ")
|
||||
if !ok {
|
||||
return "", ""
|
||||
}
|
||||
return strings.ToLower(scheme), strings.TrimSpace(value)
|
||||
}
|
||||
|
||||
// parseBasic: base64(username:password), UTF-8. Двоеточие допустимо в пароле, но не в username.
|
||||
func parseBasic(r *http.Request) (username, password string, ok bool) {
|
||||
scheme, value := splitAuthorization(r)
|
||||
if scheme != "basic" || value == "" {
|
||||
return "", "", false
|
||||
}
|
||||
decoded, err := base64.StdEncoding.DecodeString(value)
|
||||
if err != nil || len(decoded) > 1024 || !utf8.Valid(decoded) {
|
||||
return "", "", false
|
||||
}
|
||||
username, password, ok = strings.Cut(string(decoded), ":")
|
||||
return username, password, ok
|
||||
}
|
||||
|
||||
// bearerToken возвращает токен только из «Authorization: Bearer …». X-User-Id и Basic игнорируются.
|
||||
func bearerToken(r *http.Request) (string, bool) {
|
||||
scheme, value := splitAuthorization(r)
|
||||
if scheme != "bearer" || !tokenPattern.MatchString(value) {
|
||||
return "", false
|
||||
}
|
||||
return value, true
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
# Лабораторная 2: API (Go) → PostgreSQL. Запуск: docker compose up -d --build
|
||||
# Секреты лежат в ./secrets (создаются scripts/init-secrets.*, в Git не попадают).
|
||||
name: mtusi-lab2
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.9-bookworm
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
# Явно включённая устойчивость: COMMIT подтверждается после fsync WAL на диск.
|
||||
command: ["postgres", "-c", "fsync=on", "-c", "synchronous_commit=on", "-c", "full_page_writes=on"]
|
||||
secrets:
|
||||
- postgres_password
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
networks:
|
||||
- backend
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 12
|
||||
start_period: 10s
|
||||
stop_grace_period: 30s
|
||||
# Порт БД наружу не публикуется: к ней ходит только API по сети backend.
|
||||
|
||||
# Одноразовая задача: применяет только ещё не применённые миграции и завершается.
|
||||
# Безопасна при повторном запуске: docker compose run --rm migrate
|
||||
migrate:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
command: ["migrate"]
|
||||
restart: "no"
|
||||
environment:
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
secrets:
|
||||
- database_url
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
networks:
|
||||
- backend
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SESSION_STORE: postgres
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
DB_MAX_CONNS: ${DB_MAX_CONNS:-10}
|
||||
secrets:
|
||||
- database_url
|
||||
ports:
|
||||
- "127.0.0.1:${PUBLISHED_PORT:-8080}:8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
networks:
|
||||
- frontend
|
||||
- backend
|
||||
read_only: true
|
||||
cap_drop:
|
||||
- ALL
|
||||
security_opt:
|
||||
- no-new-privileges:true
|
||||
mem_limit: 512m
|
||||
stop_grace_period: 15s
|
||||
|
||||
networks:
|
||||
frontend: {}
|
||||
backend:
|
||||
internal: true # из этой сети нет выхода наружу; в ней только БД и клиенты БД
|
||||
|
||||
volumes:
|
||||
pgdata: {} # именованный volume: переживает stop/start/restart/up; удаляется только `down -v`
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
@@ -0,0 +1,80 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Config собирается только из переменных окружения (см. .env.example).
|
||||
// Секреты (строка подключения к БД) читаются из файла, а не из env.
|
||||
type Config struct {
|
||||
Host string
|
||||
Port string
|
||||
SessionTTLSecs int
|
||||
SessionStore string
|
||||
DatabaseURL string
|
||||
DBMaxConns int32
|
||||
}
|
||||
|
||||
func envOr(name, fallback string) string {
|
||||
if v := os.Getenv(name); v != "" {
|
||||
return v
|
||||
}
|
||||
return fallback
|
||||
}
|
||||
|
||||
func envInt(name string, fallback, min, max int) (int, error) {
|
||||
raw := os.Getenv(name)
|
||||
if raw == "" {
|
||||
return fallback, nil
|
||||
}
|
||||
n, err := strconv.Atoi(raw)
|
||||
if err != nil || n < min || n > max {
|
||||
return 0, fmt.Errorf("%s must be an integer in [%d, %d]", name, min, max)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
// readSecretFile читает секрет из файла (Docker secrets); BOM и перевод строки отбрасываются,
|
||||
// чтобы файл, созданный в Windows PowerShell, работал так же, как созданный в Linux.
|
||||
func readSecretFile(path string) (string, error) {
|
||||
raw, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return strings.TrimSpace(strings.TrimPrefix(string(raw), "\xEF\xBB\xBF")), nil
|
||||
}
|
||||
|
||||
func loadConfig() (Config, error) {
|
||||
cfg := Config{Host: envOr("APP_HOST", "0.0.0.0"), Port: envOr("APP_PORT", "8080")}
|
||||
if _, err := strconv.Atoi(cfg.Port); err != nil {
|
||||
return cfg, fmt.Errorf("APP_PORT must be an integer")
|
||||
}
|
||||
ttl, err := envInt("SESSION_TTL_SECONDS", 3600, 1, 30*24*3600)
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
cfg.SessionTTLSecs = ttl
|
||||
conns, err := envInt("DB_MAX_CONNS", 10, 1, 100)
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
cfg.DBMaxConns = int32(conns)
|
||||
cfg.SessionStore = envOr("SESSION_STORE", "postgres")
|
||||
if cfg.SessionStore != "postgres" {
|
||||
return cfg, fmt.Errorf("SESSION_STORE=%q is not supported at grade 3 (only \"postgres\")", cfg.SessionStore)
|
||||
}
|
||||
if file := os.Getenv("DATABASE_URL_FILE"); file != "" {
|
||||
if cfg.DatabaseURL, err = readSecretFile(file); err != nil {
|
||||
return cfg, fmt.Errorf("cannot read DATABASE_URL_FILE: %w", err)
|
||||
}
|
||||
} else {
|
||||
cfg.DatabaseURL = os.Getenv("DATABASE_URL") // только для локальной отладки без Docker secrets
|
||||
}
|
||||
if cfg.DatabaseURL == "" {
|
||||
return cfg, fmt.Errorf("set DATABASE_URL_FILE (path to a file with the PostgreSQL URL)")
|
||||
}
|
||||
return cfg, nil
|
||||
}
|
||||
@@ -0,0 +1,255 @@
|
||||
# Доказательства lab2 (уровень 3)
|
||||
|
||||
Исходные сведения архива: Соколов Илья Сергеевич, БВТ2302; дата 2026-10-12. Разделы 1–9 получены из исходного отчёта: Linux x86_64, 6 CPU, PostgreSQL 16.2 (бинарники pgserver, без Docker), Go 1.23.8 (CGO_ENABLED=0). **Раздел 10 добавлен по выводу проверок Windows 12–13 октября 2026.** Исполнитель проверки Windows / группа: **[указать действительные ФИО и группу]**. Токены и пароли не приводятся.
|
||||
|
||||
> Разделы 1–9 описывают прежние Linux-проверки без Docker. В разделе 10 зафиксированы дополнительные проверки с работающим Docker Desktop на Windows; `restart.sh` на Windows не испытывался, использовался `restart.cmd`.
|
||||
|
||||
## 1. Миграции с нуля и повторный запуск
|
||||
```
|
||||
$ messenger migrate # запуск 1
|
||||
migrate: applied 001_init
|
||||
migrate: applied 002_sessions
|
||||
migrate: done, 2 new, 2 total
|
||||
$ messenger migrate # запуск 2
|
||||
migrate: done, 0 new, 2 total
|
||||
```
|
||||
|
||||
```
|
||||
$ psql -c "select version, left(checksum,12) as checksum from schema_migrations"
|
||||
version | checksum
|
||||
--------------+--------------
|
||||
001_init | 3680831b0d09
|
||||
002_sessions | 53f051c492d9
|
||||
(2 rows)
|
||||
|
||||
```
|
||||
|
||||
## 2. Ключи, ограничения и индексы
|
||||
```
|
||||
chat_members chat_members_chat_id_fkey FOREIGN KEY
|
||||
chat_members chat_members_pkey PRIMARY KEY
|
||||
chat_members chat_members_user_id_fkey FOREIGN KEY
|
||||
chats chats_created_by_fkey FOREIGN KEY
|
||||
chats chats_pkey PRIMARY KEY
|
||||
chats chats_title_len CHECK
|
||||
messages messages_chat_id_fkey FOREIGN KEY
|
||||
messages messages_pkey PRIMARY KEY
|
||||
messages messages_sender_id_fkey FOREIGN KEY
|
||||
messages messages_text_len CHECK
|
||||
schema_migrations schema_migrations_pkey PRIMARY KEY
|
||||
sessions sessions_expiry_after_create CHECK
|
||||
sessions sessions_pkey PRIMARY KEY
|
||||
sessions sessions_token_hash_len CHECK
|
||||
sessions sessions_user_id_fkey FOREIGN KEY
|
||||
users users_display_name_len CHECK
|
||||
users users_pkey PRIMARY KEY
|
||||
users users_username_format CHECK
|
||||
users users_username_key UNIQUE
|
||||
--- indexes (кроме PK) ---
|
||||
chat_members chat_members_user_idx
|
||||
chats chats_created_at_id_idx
|
||||
messages messages_chat_created_id_idx
|
||||
sessions sessions_expires_at_idx
|
||||
sessions sessions_user_idx
|
||||
users users_username_key
|
||||
```
|
||||
|
||||
## 3. Публичные проверки (API на локальном PostgreSQL)
|
||||
```
|
||||
$ make check
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
$ make test
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
$ make student-test
|
||||
python3 student-tests/extra_checks.py --base-url "http://localhost:8080"
|
||||
OK регистрация одного username в гонке: 1×201 + 11×409
|
||||
OK создание чата с неизвестным участником: 400, чатов нет (атомарность)
|
||||
OK негативные сценарии аутентификации (401/400, токен непрозрачный)
|
||||
PASS
|
||||
```
|
||||
|
||||
## 4. Сохранность после рестарта API и PostgreSQL
|
||||
Хук: остановить API (SIGTERM), `pg_ctl -m fast stop`, `pg_ctl start`, запустить API; каталог данных PostgreSQL не пересоздаётся (аналог `docker compose stop/start` с сохранением volume).
|
||||
```
|
||||
pid postgres до: 10884
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
pid postgres после: 11037
|
||||
```
|
||||
|
||||
## 5. Срок жизни сессии (API с SESSION_TTL_SECONDS=2) и logout
|
||||
```
|
||||
OK сессия с TTL≈2 с действовала, после истечения — 401
|
||||
PASS
|
||||
(logout: 204 → 401 → повторный logout 401 — проверяется в tests/smoke.py и TestSessionLifecycle)
|
||||
```
|
||||
|
||||
## 6. Go-тесты (юнит + интеграция с PostgreSQL)
|
||||
```
|
||||
$ TEST_DATABASE_URL=… go test -count=1 -v ./...
|
||||
--- PASS: TestCursorIsBoundToResource (0.00s)
|
||||
--- PASS: TestBasicParsing (0.00s)
|
||||
--- PASS: TestTokenAndPasswordHash (0.74s)
|
||||
--- PASS: TestRegistrationRaceYieldsOneUser (1.33s)
|
||||
--- PASS: TestCreateChatIsAtomic (0.48s)
|
||||
--- PASS: TestSessionLifecycle (2.50s)
|
||||
--- PASS: TestMigrationsAreIdempotent (0.37s)
|
||||
PASS
|
||||
ok mtusi-messenger 5.452s
|
||||
```
|
||||
|
||||
## 7. Пароль хранится как Argon2id
|
||||
```
|
||||
password_hash: $argon2id$v=19$m=65536,t=3,p=2$63MBTwjDL5t…
|
||||
```
|
||||
|
||||
## 8. Отказ PostgreSQL при работающем API
|
||||
```
|
||||
PostgreSQL остановлен
|
||||
GET /health/live -> 200
|
||||
GET /health/ready -> 503
|
||||
GET /users/me (Bearer) -> 503
|
||||
PostgreSQL запущен снова
|
||||
GET /health/ready -> 200
|
||||
```
|
||||
|
||||
## 9. Секреты и тома не попадают в Git
|
||||
Во временной копии создан `secrets/`, `.env`, `pgdata/`, `volumes/`, затем `git init && git add -A`: ни один из этих путей не вошёл в `git ls-files` (50 файлов — исходники, миграции, скрипты, Dockerfile, compose.yaml, go.sum).
|
||||
|
||||
## 10. Docker на Windows — фактические результаты, 12–13 октября 2026 года
|
||||
|
||||
Окружение: Windows PowerShell (`D:\Study\sem_7\Высоконагруженные системы\Лабы\2`), Docker Desktop 4.78.0 (Engine 29.5.3, Linux containers на WSL 2, amd64), Python 3.12. Команды ниже запускались пользователем и результаты зафиксированы в диалоге; время `StartedAt` Docker приведено в UTC. Секреты не включены.
|
||||
|
||||
### 10.1. Сборка, контейнеры и readiness
|
||||
|
||||
```powershell
|
||||
docker compose --env-file .env up -d --build
|
||||
docker compose --env-file .env ps -a
|
||||
```
|
||||
|
||||
```text
|
||||
NAME IMAGE SERVICE STATUS PORTS
|
||||
mtusi-lab2-api-1 mtusi-messenger:lab2 api Up (healthy) 127.0.0.1:8080->8080/tcp
|
||||
mtusi-lab2-migrate-1 mtusi-messenger:lab2 migrate Exited (0)
|
||||
mtusi-lab2-postgres-1 postgres:16.9-bookworm postgres Up (healthy) 5432/tcp
|
||||
```
|
||||
|
||||
```powershell
|
||||
curl.exe http://localhost:8080/health/ready
|
||||
```
|
||||
|
||||
```json
|
||||
{"status":"ok"}
|
||||
```
|
||||
|
||||
### 10.2. Публичный API, проверки структуры и дополнительные сценарии
|
||||
|
||||
```powershell
|
||||
python -X utf8 tests\smoke.py --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
```text
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
```
|
||||
|
||||
```powershell
|
||||
python -X utf8 scripts\check_contract.py
|
||||
```
|
||||
|
||||
```text
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
```
|
||||
|
||||
*Примечание:* `check_contract.py` проверяет только структуру и Python-синтаксис; работу приложения подтверждают отдельно `smoke.py` и `extra_checks.py`.
|
||||
|
||||
```powershell
|
||||
python -X utf8 student-tests\extra_checks.py --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
```text
|
||||
OK регистрация одного username в гонке: 1×201 + 11×409
|
||||
OK создание чата с неизвестным участником: 400, чатов нет (атомарность)
|
||||
OK негативные сценарии аутентификации (401/400, токен непрозрачный)
|
||||
PASS
|
||||
```
|
||||
|
||||
### 10.3. Перезапуск PostgreSQL и API с сохранением данных
|
||||
|
||||
Состояние **до** запуска `scripts/restart.cmd`:
|
||||
|
||||
```powershell
|
||||
docker inspect -f "{{.Name}} started={{.State.StartedAt}}" mtusi-lab2-postgres-1 mtusi-lab2-api-1
|
||||
```
|
||||
|
||||
```text
|
||||
/mtusi-lab2-postgres-1 started=2026-10-12T21:11:46.200147084Z
|
||||
/mtusi-lab2-api-1 started=2026-10-12T21:13:02.780926485Z
|
||||
```
|
||||
|
||||
Сценарий сохранности:
|
||||
|
||||
```powershell
|
||||
python -X utf8 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
```text
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
```
|
||||
|
||||
Состояние **после** запуска `scripts/restart.cmd`:
|
||||
|
||||
```text
|
||||
/mtusi-lab2-postgres-1 started=2026-10-12T21:15:55.769170548Z
|
||||
/mtusi-lab2-api-1 started=2026-10-12T21:16:02.240310737Z
|
||||
```
|
||||
|
||||
**Вывод:** у *обоих* контейнеров изменилось поле `StartedAt`, а `resilience.py` подтвердил сохранность ранее подтверждённых данных и действующей сессии. Таким образом, замечание `Hook scope needs operator evidence` закрывается прямым сравнением Docker-метаданных до/после. Удаление volume не производилось.
|
||||
|
||||
### 10.4. Идемпотентность миграций
|
||||
|
||||
Команда запускалась дважды:
|
||||
|
||||
```powershell
|
||||
docker compose --env-file .env run --rm migrate
|
||||
```
|
||||
|
||||
```text
|
||||
2026/10/12 21:12:23 migrate: done, 0 new, 2 total
|
||||
2026/10/12 21:12:25 migrate: done, 0 new, 2 total
|
||||
```
|
||||
|
||||
**Вывод:** повторный запуск не создал дополнительных миграций.
|
||||
|
||||
### 10.5. Истечение сессии и возврат конфигурации
|
||||
|
||||
```powershell
|
||||
$env:SESSION_TTL_SECONDS = "2"
|
||||
docker compose --env-file .env up -d --force-recreate api
|
||||
python -X utf8 student-tests\extra_checks.py --expiry
|
||||
```
|
||||
|
||||
```text
|
||||
OK сессия с TTL≈2 с действовала, после истечения — 401
|
||||
PASS
|
||||
```
|
||||
|
||||
После этого тестовый TTL убран, API пересоздан с обычными настройками:
|
||||
|
||||
```powershell
|
||||
Remove-Item Env:SESSION_TTL_SECONDS
|
||||
docker compose --env-file .env up -d --force-recreate api
|
||||
```
|
||||
|
||||
```text
|
||||
✔ Container mtusi-lab2-postgres-1 Healthy
|
||||
✔ Container mtusi-lab2-api-1 Started
|
||||
✔ Container mtusi-lab2-migrate-1 Exited
|
||||
```
|
||||
|
||||
### 10.6. Примечания и границы доказательств
|
||||
|
||||
- В начале настройки возникала сетевая ошибка Docker Hub `TLS handshake timeout`, но последующий Compose-запуск прошёл успешно; это не ошибка API или миграций.
|
||||
- На Windows Python без указания UTF-8 не смог прочитать `lab.json` из-за `cp1252`; запуск тестов с `python -X utf8` решил проблему без изменения файлов.
|
||||
- `Test-NetConnection auth.docker.io -Port 443` вернул `TcpTestSucceeded : True` (это проверка TCP, а не всех стадий HTTPS).
|
||||
- `scripts/restart.sh` под Linux, потеря самого Docker-volume и целевой уровень 4 с Redis/Valkey на Windows не проверялись и **не заявляются**.
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 2,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 10.0,
|
||||
"elapsed_seconds": 10.031,
|
||||
"concurrency": 2,
|
||||
"successful_requests": 2348,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 234.074,
|
||||
"successful_latency_ms": {
|
||||
"p50": 0.0,
|
||||
"p95": 31.0,
|
||||
"p99": 32.0
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
module mtusi-messenger
|
||||
|
||||
go 1.23
|
||||
|
||||
require (
|
||||
github.com/alexedwards/argon2id v1.0.0
|
||||
github.com/jackc/pgx/v5 v5.7.2
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
|
||||
github.com/jackc/puddle/v2 v2.2.2 // indirect
|
||||
golang.org/x/crypto v0.31.0 // indirect
|
||||
golang.org/x/sync v0.10.0 // indirect
|
||||
golang.org/x/sys v0.28.0 // indirect
|
||||
golang.org/x/text v0.21.0 // indirect
|
||||
)
|
||||
@@ -0,0 +1,70 @@
|
||||
github.com/alexedwards/argon2id v1.0.0 h1:wJzDx66hqWX7siL/SRUmgz3F8YMrd/nfX/xHHcQQP0w=
|
||||
github.com/alexedwards/argon2id v1.0.0/go.mod h1:tYKkqIjzXvZdzPvADMWOEZ+l6+BD6CtBXMj5fnJppiw=
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||
github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI=
|
||||
github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
|
||||
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
|
||||
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
|
||||
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
|
||||
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
|
||||
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
|
||||
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
|
||||
golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
|
||||
golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
|
||||
golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
|
||||
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
|
||||
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
|
||||
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
|
||||
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
|
||||
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
|
||||
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
|
||||
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
|
||||
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||
golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
|
||||
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
|
||||
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
|
||||
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
|
||||
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
|
||||
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
|
||||
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
|
||||
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
|
||||
golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
|
||||
golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
||||
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
|
||||
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
|
||||
golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
|
||||
golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
|
||||
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
|
||||
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
|
||||
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
|
||||
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
|
||||
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
|
||||
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
|
||||
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
+384
@@ -0,0 +1,384 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"log"
|
||||
"net/http"
|
||||
"runtime/debug"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
type API struct {
|
||||
store *Store
|
||||
hasher *Hasher
|
||||
ttlSecs int
|
||||
reqLimit time.Duration
|
||||
}
|
||||
|
||||
// ---- аутентификация ----
|
||||
|
||||
// actor: «кто вы». Только действующая Bearer-сессия из PostgreSQL; ответ на любой сбой одинаков.
|
||||
func (a *API) actor(r *http.Request) (User, string, *apiError) {
|
||||
token, ok := bearerToken(r)
|
||||
if !ok {
|
||||
return User{}, "", unauthorized(bearerChallenge, "Требуется Authorization: Bearer <token>")
|
||||
}
|
||||
user, err := a.store.sessionUser(r.Context(), hashToken(token))
|
||||
if errors.Is(err, errNotFound) {
|
||||
return User{}, "", unauthorized(bearerChallenge, "Недействительная сессия")
|
||||
}
|
||||
if err != nil {
|
||||
return User{}, "", dbFail(err)
|
||||
}
|
||||
return user, token, nil
|
||||
}
|
||||
|
||||
func (a *API) createSession(r *http.Request) (int, any, *apiError) {
|
||||
denied := unauthorized(basicChallenge, "Неверные учётные данные")
|
||||
username, password, ok := parseBasic(r)
|
||||
if !ok {
|
||||
return 0, nil, denied
|
||||
}
|
||||
user, hash, err := a.store.userWithHash(r.Context(), username)
|
||||
found := err == nil
|
||||
if err != nil && !errors.Is(err, errNotFound) {
|
||||
return 0, nil, dbFail(err)
|
||||
}
|
||||
if !found {
|
||||
hash = a.hasher.dummy
|
||||
}
|
||||
match, herr := a.hasher.verify(r.Context(), password, hash)
|
||||
if herr != nil && !errors.Is(herr, context.Canceled) && !errors.Is(herr, context.DeadlineExceeded) {
|
||||
match = false // повреждённый хеш = отказ, не 500
|
||||
} else if herr != nil {
|
||||
return 0, nil, unavailable()
|
||||
}
|
||||
if !found || !match {
|
||||
return 0, nil, denied
|
||||
}
|
||||
token, tokenHash := newToken()
|
||||
expires, err := a.store.createSession(r.Context(), tokenHash, user.ID, a.ttlSecs)
|
||||
if err != nil {
|
||||
return 0, nil, dbFail(err)
|
||||
}
|
||||
return http.StatusCreated, map[string]any{
|
||||
"token": token, "token_type": "Bearer", "expires_at": formatTime(expires), "user": user,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (a *API) revokeSession(r *http.Request) (int, any, *apiError) {
|
||||
_, token, err := a.actor(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
if rerr := a.store.revokeSession(r.Context(), hashToken(token)); rerr != nil {
|
||||
return 0, nil, dbFail(rerr)
|
||||
}
|
||||
return http.StatusNoContent, nil, nil
|
||||
}
|
||||
|
||||
// ---- пользователи ----
|
||||
|
||||
func (a *API) createUser(r *http.Request) (int, any, *apiError) {
|
||||
body, err := readJSON(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
if err := exactFields(body, "username", "display_name", "password"); err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
username, ok := body["username"].(string)
|
||||
if !ok || !usernamePattern.MatchString(username) {
|
||||
return 0, nil, invalid("Некорректный username")
|
||||
}
|
||||
displayName, err := requiredString(body["display_name"], 100, "display_name")
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
password, ok := body["password"].(string)
|
||||
if n := utf8.RuneCountInString(password); !ok || !utf8.ValidString(password) || n < 12 || n > 128 {
|
||||
return 0, nil, invalid("Некорректный password")
|
||||
}
|
||||
hash, herr := a.hasher.hash(r.Context(), password)
|
||||
if herr != nil {
|
||||
return 0, nil, unavailable()
|
||||
}
|
||||
user, serr := a.store.createUser(r.Context(), User{ID: newUUID(), Username: username, DisplayName: displayName}, hash)
|
||||
if errors.Is(serr, errConflict) {
|
||||
return 0, nil, fail(http.StatusConflict, "conflict", "Username уже занят")
|
||||
}
|
||||
if serr != nil {
|
||||
return 0, nil, dbFail(serr)
|
||||
}
|
||||
return http.StatusCreated, user, nil
|
||||
}
|
||||
|
||||
func (a *API) currentUser(r *http.Request) (int, any, *apiError) {
|
||||
user, _, err := a.actor(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
return http.StatusOK, user, nil
|
||||
}
|
||||
|
||||
// ---- чаты ----
|
||||
|
||||
func (a *API) createChat(r *http.Request) (int, any, *apiError) {
|
||||
actor, _, err := a.actor(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
body, err := readJSON(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
if err := exactFields(body, "title", "member_ids"); err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
title, err := requiredString(body["title"], 100, "title")
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
rawMembers, ok := body["member_ids"].([]any)
|
||||
if !ok || len(rawMembers) < 1 || len(rawMembers) > 100 {
|
||||
return 0, nil, invalid("Некорректные участники")
|
||||
}
|
||||
members, seen := make([]string, 0, len(rawMembers)), map[string]bool{}
|
||||
for _, raw := range rawMembers {
|
||||
member, typeOK := raw.(string)
|
||||
id, idOK := validUUID(member)
|
||||
if !typeOK || !idOK || seen[id] {
|
||||
return 0, nil, invalid("Некорректные участники")
|
||||
}
|
||||
seen[id] = true
|
||||
members = append(members, id)
|
||||
}
|
||||
if !seen[actor.ID] {
|
||||
return 0, nil, invalid("Создатель должен быть участником")
|
||||
}
|
||||
sort.Strings(members) // детерминированный порядок: одинаковый в POST и GET
|
||||
chat, serr := a.store.createChat(r.Context(), Chat{ID: newUUID(), Title: title, MemberIDs: members}, actor.ID)
|
||||
if errors.Is(serr, errInvalidMembers) {
|
||||
return 0, nil, invalid("Некорректные участники")
|
||||
}
|
||||
if serr != nil {
|
||||
return 0, nil, dbFail(serr)
|
||||
}
|
||||
return http.StatusCreated, chat, nil
|
||||
}
|
||||
|
||||
func (a *API) listChats(r *http.Request) (int, any, *apiError) {
|
||||
actor, _, err := a.actor(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
limit, rawCursor, err := parsePage(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
var after *time.Time
|
||||
var afterID string
|
||||
if rawCursor != "" {
|
||||
t, id, cerr := decodeCursor(rawCursor, "chats", actor.ID)
|
||||
if cerr != nil {
|
||||
return 0, nil, cerr
|
||||
}
|
||||
after, afterID = &t, id
|
||||
}
|
||||
items, next, serr := a.store.listChats(r.Context(), actor.ID, limit, after, afterID)
|
||||
if serr != nil {
|
||||
return 0, nil, dbFail(serr)
|
||||
}
|
||||
return http.StatusOK, pageBody(items, next), nil
|
||||
}
|
||||
|
||||
func pageBody(items any, next string) map[string]any {
|
||||
var cursor any
|
||||
if next != "" {
|
||||
cursor = next
|
||||
}
|
||||
return map[string]any{"items": items, "next_cursor": cursor}
|
||||
}
|
||||
|
||||
// chatAccess: сначала аутентификация (вызывается до этого), затем доступ к конкретному чату.
|
||||
// Чужой и несуществующий чат неразличимы: оба дают 404.
|
||||
func (a *API) chatAccess(r *http.Request, actorID, rawID string) (string, *apiError) {
|
||||
id, ok := validUUID(rawID)
|
||||
if !ok {
|
||||
return "", invalid("Некорректный идентификатор")
|
||||
}
|
||||
member, err := a.store.isMember(r.Context(), actorID, id)
|
||||
if err != nil {
|
||||
return "", dbFail(err)
|
||||
}
|
||||
if !member {
|
||||
return "", notFound()
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
func (a *API) getChat(r *http.Request, rawID string) (int, any, *apiError) {
|
||||
actor, _, err := a.actor(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
id, ok := validUUID(rawID)
|
||||
if !ok {
|
||||
return 0, nil, invalid("Некорректный идентификатор")
|
||||
}
|
||||
chat, serr := a.store.getChat(r.Context(), actor.ID, id)
|
||||
if errors.Is(serr, errNotFound) {
|
||||
return 0, nil, notFound()
|
||||
}
|
||||
if serr != nil {
|
||||
return 0, nil, dbFail(serr)
|
||||
}
|
||||
return http.StatusOK, chat, nil
|
||||
}
|
||||
|
||||
// ---- сообщения ----
|
||||
|
||||
func (a *API) createMessage(r *http.Request, rawID string) (int, any, *apiError) {
|
||||
actor, _, err := a.actor(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
chatID, err := a.chatAccess(r, actor.ID, rawID)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
body, err := readJSON(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
// sender_id в теле не принимается: лишнее поле — 400. Отправитель берётся только из сессии.
|
||||
if err := exactFields(body, "text"); err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
text, err := requiredString(body["text"], 4000, "text")
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
message, serr := a.store.createMessage(r.Context(), Message{ID: newUUID(), ChatID: chatID, SenderID: actor.ID, Text: text})
|
||||
if serr != nil {
|
||||
return 0, nil, dbFail(serr)
|
||||
}
|
||||
return http.StatusCreated, message, nil
|
||||
}
|
||||
|
||||
func (a *API) listMessages(r *http.Request, rawID string) (int, any, *apiError) {
|
||||
actor, _, err := a.actor(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
chatID, err := a.chatAccess(r, actor.ID, rawID)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
limit, rawCursor, err := parsePage(r)
|
||||
if err != nil {
|
||||
return 0, nil, err
|
||||
}
|
||||
var after *time.Time
|
||||
var afterID string
|
||||
if rawCursor != "" {
|
||||
t, id, cerr := decodeCursor(rawCursor, "messages", chatID)
|
||||
if cerr != nil {
|
||||
return 0, nil, cerr
|
||||
}
|
||||
after, afterID = &t, id
|
||||
}
|
||||
items, next, serr := a.store.listMessages(r.Context(), chatID, limit, after, afterID)
|
||||
if serr != nil {
|
||||
return 0, nil, dbFail(serr)
|
||||
}
|
||||
return http.StatusOK, pageBody(items, next), nil
|
||||
}
|
||||
|
||||
// ---- health ----
|
||||
|
||||
func (a *API) ready(r *http.Request) (int, any, *apiError) {
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
|
||||
defer cancel()
|
||||
if err := a.store.ready(ctx); err != nil {
|
||||
log.Printf("readiness: dependency check failed")
|
||||
return 0, nil, unavailable()
|
||||
}
|
||||
return http.StatusOK, map[string]string{"status": "ok"}, nil
|
||||
}
|
||||
|
||||
// ---- маршрутизация ----
|
||||
|
||||
func (a *API) dispatch(r *http.Request) (int, any, *apiError) {
|
||||
path := r.URL.Path
|
||||
switch {
|
||||
case r.Method == http.MethodGet && path == "/health/live":
|
||||
return http.StatusOK, map[string]string{"status": "ok"}, nil
|
||||
case r.Method == http.MethodGet && path == "/health/ready":
|
||||
return a.ready(r)
|
||||
case r.Method == http.MethodPost && path == "/api/v1/users":
|
||||
return a.createUser(r)
|
||||
case r.Method == http.MethodGet && path == "/api/v1/users/me":
|
||||
return a.currentUser(r)
|
||||
case r.Method == http.MethodPost && path == "/api/v1/auth/sessions":
|
||||
return a.createSession(r) // единственное место, где принимается Basic
|
||||
case r.Method == http.MethodDelete && path == "/api/v1/auth/sessions/current":
|
||||
return a.revokeSession(r)
|
||||
case r.Method == http.MethodPost && path == "/api/v1/chats":
|
||||
return a.createChat(r)
|
||||
case r.Method == http.MethodGet && path == "/api/v1/chats":
|
||||
return a.listChats(r)
|
||||
}
|
||||
parts := strings.Split(strings.Trim(path, "/"), "/")
|
||||
if len(parts) == 4 && strings.Join(parts[:3], "/") == "api/v1/chats" && r.Method == http.MethodGet {
|
||||
return a.getChat(r, parts[3])
|
||||
}
|
||||
if len(parts) == 5 && strings.Join(parts[:3], "/") == "api/v1/chats" && parts[4] == "messages" {
|
||||
if r.Method == http.MethodPost {
|
||||
return a.createMessage(r, parts[3])
|
||||
}
|
||||
if r.Method == http.MethodGet {
|
||||
return a.listMessages(r, parts[3])
|
||||
}
|
||||
}
|
||||
return 0, nil, notFound()
|
||||
}
|
||||
|
||||
type statusWriter struct {
|
||||
http.ResponseWriter
|
||||
status int
|
||||
}
|
||||
|
||||
func (w *statusWriter) WriteHeader(code int) { w.status = code; w.ResponseWriter.WriteHeader(code) }
|
||||
|
||||
func (a *API) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
|
||||
id := newUUID()
|
||||
w := &statusWriter{ResponseWriter: rw, status: 200}
|
||||
started := time.Now()
|
||||
ctx, cancel := context.WithTimeout(r.Context(), a.reqLimit)
|
||||
defer cancel()
|
||||
r = r.WithContext(ctx)
|
||||
defer func() {
|
||||
if rec := recover(); rec != nil {
|
||||
log.Printf("panic request_id=%s: %v\n%s", id, rec, debug.Stack())
|
||||
writeError(w, id, fail(http.StatusInternalServerError, "internal_error", "Внутренняя ошибка"))
|
||||
}
|
||||
// В лог не попадают заголовки, query-строка, тела запросов и токены.
|
||||
log.Printf("%s %s -> %d request_id=%s %s", r.Method, r.URL.Path, w.status, id, time.Since(started).Round(time.Millisecond))
|
||||
}()
|
||||
status, body, err := a.dispatch(r)
|
||||
if err != nil {
|
||||
writeError(w, id, err)
|
||||
return
|
||||
}
|
||||
if status == http.StatusNoContent {
|
||||
w.Header().Set("X-Request-Id", id)
|
||||
w.WriteHeader(status)
|
||||
return
|
||||
}
|
||||
writeJSON(w, id, status, body)
|
||||
}
|
||||
@@ -0,0 +1,203 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"mime"
|
||||
"net/http"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
const maxJSONBytes = 1 << 20
|
||||
|
||||
var (
|
||||
usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
|
||||
uuidPattern = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
|
||||
)
|
||||
|
||||
type apiError struct {
|
||||
status int
|
||||
code, message string
|
||||
challenge string // значение WWW-Authenticate для 401
|
||||
}
|
||||
|
||||
func fail(status int, code, message string) *apiError {
|
||||
return &apiError{status: status, code: code, message: message}
|
||||
}
|
||||
func invalid(message string) *apiError {
|
||||
return fail(http.StatusBadRequest, "invalid_request", message)
|
||||
}
|
||||
func notFound() *apiError {
|
||||
return fail(http.StatusNotFound, "not_found", "Объект не найден")
|
||||
}
|
||||
func unavailable() *apiError {
|
||||
return fail(http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен")
|
||||
}
|
||||
func unauthorized(challenge, message string) *apiError {
|
||||
e := fail(http.StatusUnauthorized, "unauthorized", message)
|
||||
e.challenge = challenge
|
||||
return e
|
||||
}
|
||||
|
||||
const (
|
||||
bearerChallenge = `Bearer realm="messenger"`
|
||||
basicChallenge = `Basic realm="messenger", charset="UTF-8"`
|
||||
)
|
||||
|
||||
func newUUID() string {
|
||||
b := make([]byte, 16)
|
||||
if _, err := rand.Read(b); err != nil {
|
||||
panic("crypto/rand failed")
|
||||
}
|
||||
b[6] = (b[6] & 0x0f) | 0x40
|
||||
b[8] = (b[8] & 0x3f) | 0x80
|
||||
return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16])
|
||||
}
|
||||
|
||||
// formatTime — RFC 3339 UTC, всегда 6 знаков долей секунды (точность PostgreSQL).
|
||||
func formatTime(t time.Time) string { return t.UTC().Format("2006-01-02T15:04:05.000000Z") }
|
||||
|
||||
func validUUID(value string) (string, bool) {
|
||||
if !uuidPattern.MatchString(value) {
|
||||
return "", false
|
||||
}
|
||||
return strings.ToLower(value), true
|
||||
}
|
||||
|
||||
// cleanText: валидный UTF-8 без NUL (PostgreSQL не хранит \x00 в text).
|
||||
func cleanText(s string) bool { return utf8.ValidString(s) && !strings.ContainsRune(s, 0) }
|
||||
|
||||
func requiredString(value any, limit int, field string) (string, *apiError) {
|
||||
text, ok := value.(string)
|
||||
if !ok || text == "" || strings.TrimSpace(text) == "" || !cleanText(text) || utf8.RuneCountInString(text) > limit {
|
||||
return "", invalid("Некорректное поле " + field)
|
||||
}
|
||||
return text, nil
|
||||
}
|
||||
|
||||
func exactFields(body map[string]any, expected ...string) *apiError {
|
||||
if len(body) != len(expected) {
|
||||
return invalid("Неожиданные или отсутствующие поля")
|
||||
}
|
||||
for _, name := range expected {
|
||||
if _, ok := body[name]; !ok {
|
||||
return invalid("Неожиданные или отсутствующие поля")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func readJSON(r *http.Request) (map[string]any, *apiError) {
|
||||
mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
|
||||
if err != nil || mediaType != "application/json" {
|
||||
return nil, fail(http.StatusUnsupportedMediaType, "unsupported_media_type", "Требуется application/json")
|
||||
}
|
||||
raw, err := io.ReadAll(io.LimitReader(r.Body, maxJSONBytes+1))
|
||||
if err != nil {
|
||||
return nil, invalid("Некорректное тело запроса")
|
||||
}
|
||||
if len(raw) > maxJSONBytes {
|
||||
return nil, fail(http.StatusRequestEntityTooLarge, "payload_too_large", "Слишком большой JSON")
|
||||
}
|
||||
if !utf8.Valid(raw) {
|
||||
return nil, invalid("Некорректный JSON")
|
||||
}
|
||||
decoder := json.NewDecoder(strings.NewReader(string(raw)))
|
||||
var body map[string]any
|
||||
if err := decoder.Decode(&body); err != nil || body == nil {
|
||||
return nil, invalid("Некорректный JSON")
|
||||
}
|
||||
var trailing any
|
||||
if err := decoder.Decode(&trailing); err != io.EOF {
|
||||
return nil, invalid("Некорректный JSON")
|
||||
}
|
||||
return body, nil
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, id string, status int, body any) {
|
||||
w.Header().Set("X-Request-Id", id)
|
||||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||
w.WriteHeader(status)
|
||||
enc := json.NewEncoder(w)
|
||||
enc.SetEscapeHTML(false)
|
||||
_ = enc.Encode(body)
|
||||
}
|
||||
|
||||
func writeError(w http.ResponseWriter, id string, err *apiError) {
|
||||
if err.challenge != "" {
|
||||
w.Header().Set("WWW-Authenticate", err.challenge)
|
||||
}
|
||||
writeJSON(w, id, err.status, map[string]any{"error": map[string]string{"code": err.code, "message": err.message, "request_id": id}})
|
||||
}
|
||||
|
||||
func parsePage(r *http.Request) (int, string, *apiError) {
|
||||
query := r.URL.Query()
|
||||
if len(query["limit"]) > 1 || len(query["cursor"]) > 1 {
|
||||
return 0, "", invalid("Повторяющийся параметр пагинации")
|
||||
}
|
||||
limit := 50
|
||||
if values, exists := query["limit"]; exists {
|
||||
n, err := strconv.Atoi(values[0])
|
||||
if err != nil || n < 1 || n > 100 || strconv.Itoa(n) != values[0] {
|
||||
return 0, "", invalid("Некорректный limit")
|
||||
}
|
||||
limit = n
|
||||
}
|
||||
if values, exists := query["cursor"]; exists {
|
||||
if values[0] == "" {
|
||||
return 0, "", invalid("Некорректный cursor")
|
||||
}
|
||||
return limit, values[0], nil
|
||||
}
|
||||
return limit, "", nil
|
||||
}
|
||||
|
||||
// cursor — непрозрачная для клиента строка: ключ (created_at, id) + тип списка + владелец
|
||||
// (id чата либо пользователя). Курсор другого ресурса отклоняется с 400.
|
||||
type cursor struct {
|
||||
Kind string `json:"k"`
|
||||
Owner string `json:"o"`
|
||||
Time string `json:"t"`
|
||||
ID string `json:"i"`
|
||||
}
|
||||
|
||||
func encodeCursor(kind, owner string, created time.Time, id string) string {
|
||||
raw, _ := json.Marshal(cursor{kind, owner, formatTime(created), id})
|
||||
return base64.RawURLEncoding.EncodeToString(raw)
|
||||
}
|
||||
|
||||
func decodeCursor(value, kind, owner string) (time.Time, string, *apiError) {
|
||||
raw, err := base64.RawURLEncoding.DecodeString(value)
|
||||
if err != nil {
|
||||
return time.Time{}, "", invalid("Некорректный cursor")
|
||||
}
|
||||
var fields map[string]any
|
||||
if json.Unmarshal(raw, &fields) != nil || len(fields) != 4 {
|
||||
return time.Time{}, "", invalid("Некорректный cursor")
|
||||
}
|
||||
for _, name := range []string{"k", "o", "t", "i"} {
|
||||
if _, ok := fields[name].(string); !ok {
|
||||
return time.Time{}, "", invalid("Некорректный cursor")
|
||||
}
|
||||
}
|
||||
c := cursor{fields["k"].(string), fields["o"].(string), fields["t"].(string), fields["i"].(string)}
|
||||
if c.Kind != kind || c.Owner != owner {
|
||||
return time.Time{}, "", invalid("Некорректный cursor")
|
||||
}
|
||||
id, ok := validUUID(c.ID)
|
||||
if !ok {
|
||||
return time.Time{}, "", invalid("Некорректный cursor")
|
||||
}
|
||||
t, err := time.Parse("2006-01-02T15:04:05.000000Z", c.Time)
|
||||
if err != nil {
|
||||
return time.Time{}, "", invalid("Некорректный cursor")
|
||||
}
|
||||
return t, id, nil
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"net"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
)
|
||||
|
||||
func main() {
|
||||
command := "serve"
|
||||
if len(os.Args) > 1 {
|
||||
command = os.Args[1]
|
||||
}
|
||||
switch command {
|
||||
case "serve":
|
||||
os.Exit(serve())
|
||||
case "migrate":
|
||||
os.Exit(migrateCommand())
|
||||
case "healthcheck":
|
||||
os.Exit(healthcheck())
|
||||
default:
|
||||
fmt.Fprintln(os.Stderr, "usage: messenger [serve|migrate|healthcheck]")
|
||||
os.Exit(2)
|
||||
}
|
||||
}
|
||||
|
||||
func migrateCommand() int {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
log.Printf("config error: %v", err)
|
||||
return 1
|
||||
}
|
||||
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
||||
defer stop()
|
||||
if err := runMigrations(ctx, cfg.DatabaseURL); err != nil {
|
||||
log.Printf("migrate failed: %v", err)
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// healthcheck нужен для HEALTHCHECK контейнера: в образе scratch нет ни shell, ни curl.
|
||||
func healthcheck() int {
|
||||
client := &http.Client{Timeout: 3 * time.Second}
|
||||
resp, err := client.Get("http://127.0.0.1:" + envOr("APP_PORT", "8080") + "/health/ready")
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func serve() int {
|
||||
cfg, err := loadConfig()
|
||||
if err != nil {
|
||||
log.Printf("config error: %v", err)
|
||||
return 1
|
||||
}
|
||||
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
||||
defer stop()
|
||||
|
||||
pool, err := newPool(ctx, cfg.DatabaseURL, cfg.DBMaxConns)
|
||||
if err != nil {
|
||||
log.Printf("database setup error: %v", err)
|
||||
return 1
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
api := &API{store: &Store{pool: pool}, hasher: newHasher(4), ttlSecs: cfg.SessionTTLSecs, reqLimit: 8 * time.Second}
|
||||
server := &http.Server{
|
||||
Addr: net.JoinHostPort(cfg.Host, cfg.Port),
|
||||
Handler: api,
|
||||
ReadHeaderTimeout: 5 * time.Second,
|
||||
ReadTimeout: 15 * time.Second,
|
||||
WriteTimeout: 30 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
}
|
||||
errs := make(chan error, 1)
|
||||
go func() { errs <- server.ListenAndServe() }()
|
||||
log.Printf("messenger listening on %s (session ttl %ds, max db conns %d)", server.Addr, cfg.SessionTTLSecs, cfg.DBMaxConns)
|
||||
|
||||
select {
|
||||
case err := <-errs:
|
||||
if !errors.Is(err, http.ErrServerClosed) {
|
||||
log.Printf("server error: %v", err)
|
||||
return 1
|
||||
}
|
||||
case <-ctx.Done():
|
||||
log.Printf("shutting down: finishing in-flight requests")
|
||||
shutdown, cancel := context.WithTimeout(context.Background(), 8*time.Second)
|
||||
defer cancel()
|
||||
if err := server.Shutdown(shutdown); err != nil {
|
||||
log.Printf("shutdown error: %v", err)
|
||||
return 1
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
+122
@@ -0,0 +1,122 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"embed"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"log"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
)
|
||||
|
||||
//go:embed migrations/*.sql
|
||||
var migrationFS embed.FS
|
||||
|
||||
// Произвольная константа-ключ advisory lock: параллельные запуски миграций выстраиваются в очередь.
|
||||
const migrationLockKey int64 = 7_272_026_002
|
||||
|
||||
type migration struct{ version, sql, checksum string }
|
||||
|
||||
func itoa(n int) string { return strconv.Itoa(n) }
|
||||
|
||||
func loadMigrations() []migration {
|
||||
entries, err := migrationFS.ReadDir("migrations")
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
var list []migration
|
||||
for _, e := range entries {
|
||||
if e.IsDir() || !strings.HasSuffix(e.Name(), ".sql") {
|
||||
continue
|
||||
}
|
||||
raw, err := migrationFS.ReadFile("migrations/" + e.Name())
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
sum := sha256.Sum256(raw)
|
||||
list = append(list, migration{strings.TrimSuffix(e.Name(), ".sql"), string(raw), hex.EncodeToString(sum[:])})
|
||||
}
|
||||
sort.Slice(list, func(i, j int) bool { return list[i].version < list[j].version })
|
||||
return list
|
||||
}
|
||||
|
||||
func migrationVersions() []string {
|
||||
var v []string
|
||||
for _, m := range loadMigrations() {
|
||||
v = append(v, m.version)
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// runMigrations применяет только ещё не применённые версии. Повторный запуск ничего не меняет и не трогает данные:
|
||||
// каждая версия записывается в schema_migrations в той же транзакции, что и сама миграция.
|
||||
func runMigrations(ctx context.Context, databaseURL string) error {
|
||||
var conn *pgx.Conn
|
||||
var err error
|
||||
deadline := time.Now().Add(60 * time.Second)
|
||||
for {
|
||||
cctx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
conn, err = pgx.Connect(cctx, databaseURL)
|
||||
cancel()
|
||||
if err == nil {
|
||||
break
|
||||
}
|
||||
if time.Now().After(deadline) || ctx.Err() != nil {
|
||||
return fmt.Errorf("database is not reachable: %w", err)
|
||||
}
|
||||
log.Printf("migrate: waiting for database...")
|
||||
time.Sleep(2 * time.Second)
|
||||
}
|
||||
defer conn.Close(context.Background())
|
||||
|
||||
if _, err := conn.Exec(ctx, `SELECT pg_advisory_lock($1)`, migrationLockKey); err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() { _, _ = conn.Exec(context.Background(), `SELECT pg_advisory_unlock($1)`, migrationLockKey) }()
|
||||
|
||||
if _, err := conn.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
checksum text NOT NULL,
|
||||
applied_at timestamptz NOT NULL DEFAULT now())`); err != nil {
|
||||
return err
|
||||
}
|
||||
applied := 0
|
||||
for _, m := range loadMigrations() {
|
||||
var have string
|
||||
err := conn.QueryRow(ctx, `SELECT checksum FROM schema_migrations WHERE version = $1`, m.version).Scan(&have)
|
||||
if err == nil {
|
||||
if have != m.checksum {
|
||||
return fmt.Errorf("migration %s was changed after being applied (checksum mismatch)", m.version)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if err != pgx.ErrNoRows {
|
||||
return err
|
||||
}
|
||||
tx, err := conn.Begin(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.Exec(ctx, m.sql); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return fmt.Errorf("migration %s failed: %w", m.version, err)
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)`, m.version, m.checksum); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return err
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
applied++
|
||||
log.Printf("migrate: applied %s", m.version)
|
||||
}
|
||||
log.Printf("migrate: done, %d new, %d total", applied, len(loadMigrations()))
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
-- Источник истины: пользователи, чаты, участники и сообщения.
|
||||
-- Транзакционные границы:
|
||||
-- * регистрация — один INSERT в users (уникальность username решает сама БД);
|
||||
-- * создание чата — INSERT в chats + INSERT всех участников в одной транзакции;
|
||||
-- * отправка сообщения — один INSERT в messages (id и время назначает сервер).
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
CONSTRAINT users_username_key UNIQUE (username),
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_by uuid NOT NULL REFERENCES users (id),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
|
||||
);
|
||||
-- Список чатов отсортирован по (created_at, id) — keyset-пагинация без OFFSET.
|
||||
CREATE INDEX chats_created_at_id_idx ON chats (created_at, id);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
-- «Чаты пользователя»: поиск по user_id, а не по chat_id.
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
|
||||
);
|
||||
-- История чата: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n.
|
||||
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,15 @@
|
||||
-- Серверные сессии. Клиент получает непрозрачный токен (256 бит случайности),
|
||||
-- в БД хранится только его SHA-256: утечка таблицы не раскрывает рабочие токены.
|
||||
-- Срок жизни абсолютный (expires_at) и не продлевается рестартом.
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
expires_at timestamptz NOT NULL,
|
||||
revoked_at timestamptz,
|
||||
CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32),
|
||||
CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at)
|
||||
);
|
||||
CREATE INDEX sessions_expires_at_idx ON sessions (expires_at);
|
||||
CREATE INDEX sessions_user_idx ON sessions (user_id);
|
||||
@@ -0,0 +1,25 @@
|
||||
# Creates local secrets and .env (Windows PowerShell 5.1 / PowerShell 7).
|
||||
# Existing files are NEVER overwritten: the password of an already initialised database volume
|
||||
# must keep matching secrets/postgres_password.
|
||||
$ErrorActionPreference = 'Stop'
|
||||
Set-Location (Join-Path $PSScriptRoot '..')
|
||||
$db = if ($env:POSTGRES_DB) { $env:POSTGRES_DB } else { 'messenger' }
|
||||
$user = if ($env:POSTGRES_USER) { $env:POSTGRES_USER } else { 'messenger' }
|
||||
New-Item -ItemType Directory -Force -Path 'secrets' | Out-Null
|
||||
# UTF-8 WITHOUT BOM and without a trailing newline: readable by the PostgreSQL image and by the app.
|
||||
$utf8 = New-Object System.Text.UTF8Encoding($false)
|
||||
$pwFile = Join-Path (Get-Location) 'secrets/postgres_password'
|
||||
$urlFile = Join-Path (Get-Location) 'secrets/database_url'
|
||||
if (-not (Test-Path $pwFile)) {
|
||||
$bytes = New-Object byte[] 24
|
||||
[System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
|
||||
$password = ($bytes | ForEach-Object { $_.ToString('x2') }) -join ''
|
||||
[System.IO.File]::WriteAllText($pwFile, $password, $utf8)
|
||||
Write-Host 'created secrets/postgres_password'
|
||||
}
|
||||
if (-not (Test-Path $urlFile)) {
|
||||
$password = [System.IO.File]::ReadAllText($pwFile).Trim()
|
||||
[System.IO.File]::WriteAllText($urlFile, "postgres://${user}:${password}@postgres:5432/${db}?sslmode=disable", $utf8)
|
||||
Write-Host 'created secrets/database_url'
|
||||
}
|
||||
if (-not (Test-Path '.env')) { Copy-Item '.env.example' '.env'; Write-Host 'created .env' }
|
||||
@@ -0,0 +1,23 @@
|
||||
@echo off
|
||||
rem Full restart of API and PostgreSQL, volumes are preserved (Windows). No secrets are printed.
|
||||
setlocal
|
||||
cd /d "%~dp0.." || exit /b 1
|
||||
|
||||
docker compose stop api postgres >nul 2>&1
|
||||
if errorlevel 1 exit /b 1
|
||||
docker compose start postgres >nul 2>&1
|
||||
if errorlevel 1 exit /b 1
|
||||
|
||||
set /a tries=0
|
||||
:waitpg
|
||||
docker compose exec -T postgres sh -c "pg_isready -q -U $POSTGRES_USER -d $POSTGRES_DB" >nul 2>&1
|
||||
if not errorlevel 1 goto pgready
|
||||
set /a tries+=1
|
||||
if %tries% GEQ 45 exit /b 1
|
||||
rem ping instead of timeout: timeout fails when stdin is redirected (as in tests/resilience.py)
|
||||
ping -n 2 127.0.0.1 >nul
|
||||
goto waitpg
|
||||
|
||||
:pgready
|
||||
docker compose start api >nul 2>&1
|
||||
exit /b %errorlevel%
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/bin/sh
|
||||
# Полный перезапуск API и ВСЕХ используемых хранилищ (PostgreSQL) с сохранением volumes.
|
||||
# Не использует down -v / удаление volumes / повторный seed. Вывод секретов отсутствует.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
# stop → SIGTERM (graceful): API дожидается запросов, PostgreSQL делает fast shutdown и сбрасывает WAL.
|
||||
docker compose stop api postgres >/dev/null 2>&1
|
||||
docker compose start postgres >/dev/null 2>&1
|
||||
|
||||
tries=0
|
||||
until docker compose exec -T postgres sh -c 'pg_isready -q -U "$POSTGRES_USER" -d "$POSTGRES_DB"' >/dev/null 2>&1; do
|
||||
tries=$((tries + 1))
|
||||
if [ "$tries" -ge 45 ]; then
|
||||
echo "postgres did not become ready in time" >&2
|
||||
exit 1
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
|
||||
docker compose start api >/dev/null 2>&1
|
||||
exit 0
|
||||
@@ -0,0 +1,312 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
type User struct {
|
||||
ID string `json:"id"`
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
type Chat struct {
|
||||
ID string `json:"id"`
|
||||
Title string `json:"title"`
|
||||
MemberIDs []string `json:"member_ids"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
type Message struct {
|
||||
ID string `json:"id"`
|
||||
ChatID string `json:"chat_id"`
|
||||
SenderID string `json:"sender_id"`
|
||||
Text string `json:"text"`
|
||||
CreatedAt string `json:"created_at"`
|
||||
}
|
||||
|
||||
var (
|
||||
errConflict = errors.New("conflict")
|
||||
errNotFound = errors.New("not found")
|
||||
errInvalidMembers = errors.New("invalid members")
|
||||
)
|
||||
|
||||
// Store — единственный источник истины: PostgreSQL. Все запросы параметризованы ($1, $2, …),
|
||||
// строки SQL не собираются из пользовательских данных.
|
||||
type Store struct{ pool *pgxpool.Pool }
|
||||
|
||||
func newPool(ctx context.Context, url string, maxConns int32) (*pgxpool.Pool, error) {
|
||||
cfg, err := pgxpool.ParseConfig(url)
|
||||
if err != nil {
|
||||
return nil, errors.New("invalid database URL")
|
||||
}
|
||||
cfg.MaxConns = maxConns
|
||||
cfg.MaxConnLifetime = 30 * time.Minute
|
||||
cfg.MaxConnIdleTime = 5 * time.Minute
|
||||
cfg.HealthCheckPeriod = 15 * time.Second
|
||||
cfg.ConnConfig.ConnectTimeout = 3 * time.Second
|
||||
if cfg.ConnConfig.RuntimeParams == nil {
|
||||
cfg.ConnConfig.RuntimeParams = map[string]string{}
|
||||
}
|
||||
cfg.ConnConfig.RuntimeParams["timezone"] = "UTC"
|
||||
cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000"
|
||||
cfg.ConnConfig.RuntimeParams["idle_in_transaction_session_timeout"] = "10000"
|
||||
cfg.ConnConfig.RuntimeParams["application_name"] = "messenger-api"
|
||||
// Соединения создаются лениво: API стартует и при недоступной БД (тогда /health/ready даёт 503).
|
||||
return pgxpool.NewWithConfig(ctx, cfg)
|
||||
}
|
||||
|
||||
// dbFail переводит ошибку БД в ограниченный ответ: ни SQL, ни адреса, ни текста драйвера клиенту не уходят.
|
||||
func dbFail(err error) *apiError {
|
||||
var pg *pgconn.PgError
|
||||
if errors.As(err, &pg) {
|
||||
// 08 — соединение, 53 — ресурсы, 57 — остановка/отмена, 40 — откат по конкуренции.
|
||||
switch pg.Code[:2] {
|
||||
case "08", "53", "57", "40":
|
||||
return unavailable()
|
||||
}
|
||||
return fail(500, "internal_error", "Внутренняя ошибка")
|
||||
}
|
||||
// не PgError: обрыв соединения, таймаут, пул исчерпан, БД недоступна
|
||||
return unavailable()
|
||||
}
|
||||
|
||||
func isPgCode(err error, code string) bool {
|
||||
var pg *pgconn.PgError
|
||||
return errors.As(err, &pg) && pg.Code == code
|
||||
}
|
||||
|
||||
// ---- пользователи ----
|
||||
|
||||
func (s *Store) createUser(ctx context.Context, u User, passwordHash string) (User, error) {
|
||||
var created time.Time
|
||||
err := s.pool.QueryRow(ctx,
|
||||
`INSERT INTO users (id, username, display_name, password_hash) VALUES ($1::uuid, $2, $3, $4) RETURNING created_at`,
|
||||
u.ID, u.Username, u.DisplayName, passwordHash).Scan(&created)
|
||||
if err != nil {
|
||||
if isPgCode(err, "23505") { // unique_violation: username занят, в том числе при гонке
|
||||
return User{}, errConflict
|
||||
}
|
||||
return User{}, err
|
||||
}
|
||||
u.CreatedAt = formatTime(created)
|
||||
return u, nil
|
||||
}
|
||||
|
||||
func (s *Store) userWithHash(ctx context.Context, username string) (User, string, error) {
|
||||
var u User
|
||||
var hash string
|
||||
var created time.Time
|
||||
err := s.pool.QueryRow(ctx,
|
||||
`SELECT id::text, username, display_name, created_at, password_hash FROM users WHERE username = $1`,
|
||||
username).Scan(&u.ID, &u.Username, &u.DisplayName, &created, &hash)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return User{}, "", errNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return User{}, "", err
|
||||
}
|
||||
u.CreatedAt = formatTime(created)
|
||||
return u, hash, nil
|
||||
}
|
||||
|
||||
// ---- сессии ----
|
||||
|
||||
func (s *Store) createSession(ctx context.Context, tokenHash []byte, userID string, ttlSecs int) (time.Time, error) {
|
||||
// Оппортунистическая чистка давно истёкших строк; индекс по expires_at делает её дешёвой.
|
||||
_, _ = s.pool.Exec(ctx, `DELETE FROM sessions WHERE expires_at < now() - interval '1 day'`)
|
||||
var expires time.Time
|
||||
err := s.pool.QueryRow(ctx,
|
||||
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2::uuid, now() + make_interval(secs => $3::float8)) RETURNING expires_at`,
|
||||
tokenHash, userID, float64(ttlSecs)).Scan(&expires)
|
||||
return expires, err
|
||||
}
|
||||
|
||||
// sessionUser возвращает владельца действующей (не истёкшей и не отозванной) сессии.
|
||||
// Срок проверяется по часам PostgreSQL, поэтому он не зависит от рестарта API.
|
||||
func (s *Store) sessionUser(ctx context.Context, tokenHash []byte) (User, error) {
|
||||
var u User
|
||||
var created time.Time
|
||||
err := s.pool.QueryRow(ctx,
|
||||
`SELECT u.id::text, u.username, u.display_name, u.created_at
|
||||
FROM sessions s JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()`,
|
||||
tokenHash).Scan(&u.ID, &u.Username, &u.DisplayName, &created)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return User{}, errNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return User{}, err
|
||||
}
|
||||
u.CreatedAt = formatTime(created)
|
||||
return u, nil
|
||||
}
|
||||
|
||||
func (s *Store) revokeSession(ctx context.Context, tokenHash []byte) error {
|
||||
_, err := s.pool.Exec(ctx,
|
||||
`UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL`, tokenHash)
|
||||
return err
|
||||
}
|
||||
|
||||
// ---- чаты ----
|
||||
|
||||
// createChat — составная операция: чат и ВСЕ участники появляются в одной транзакции.
|
||||
// Любая ошибка (например, несуществующий участник → FK) откатывает всё: «половинчатых» чатов не бывает.
|
||||
func (s *Store) createChat(ctx context.Context, c Chat, creatorID string) (Chat, error) {
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
defer func() { _ = tx.Rollback(context.Background()) }() // no-op после Commit
|
||||
|
||||
var created time.Time
|
||||
if err := tx.QueryRow(ctx,
|
||||
`INSERT INTO chats (id, title, created_by) VALUES ($1::uuid, $2, $3::uuid) RETURNING created_at`,
|
||||
c.ID, c.Title, creatorID).Scan(&created); err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
if _, err := tx.Exec(ctx,
|
||||
`INSERT INTO chat_members (chat_id, user_id) SELECT $1::uuid, m::uuid FROM unnest($2::text[]) AS m`,
|
||||
c.ID, c.MemberIDs); err != nil {
|
||||
if isPgCode(err, "23503") { // foreign_key_violation: неизвестный участник
|
||||
return Chat{}, errInvalidMembers
|
||||
}
|
||||
return Chat{}, err
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return Chat{}, err
|
||||
}
|
||||
c.CreatedAt = formatTime(created)
|
||||
return c, nil
|
||||
}
|
||||
|
||||
const chatColumns = `c.id::text, c.title, c.created_at,
|
||||
ARRAY(SELECT m2.user_id::text FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.user_id)`
|
||||
|
||||
func scanChat(row pgx.Row) (Chat, time.Time, error) {
|
||||
var c Chat
|
||||
var created time.Time
|
||||
if err := row.Scan(&c.ID, &c.Title, &created, &c.MemberIDs); err != nil {
|
||||
return Chat{}, time.Time{}, err
|
||||
}
|
||||
c.CreatedAt = formatTime(created)
|
||||
return c, created, nil
|
||||
}
|
||||
|
||||
func (s *Store) getChat(ctx context.Context, actorID, chatID string) (Chat, error) {
|
||||
c, _, err := scanChat(s.pool.QueryRow(ctx,
|
||||
`SELECT `+chatColumns+` FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1::uuid WHERE c.id = $2::uuid`,
|
||||
actorID, chatID))
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return Chat{}, errNotFound
|
||||
}
|
||||
return c, err
|
||||
}
|
||||
|
||||
func (s *Store) isMember(ctx context.Context, actorID, chatID string) (bool, error) {
|
||||
var ok bool
|
||||
err := s.pool.QueryRow(ctx,
|
||||
`SELECT EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $1::uuid AND user_id = $2::uuid)`,
|
||||
chatID, actorID).Scan(&ok)
|
||||
return ok, err
|
||||
}
|
||||
|
||||
// listChats: keyset-пагинация по (created_at, id); запрашивается limit+1 строк, чтобы точно знать, есть ли следующая.
|
||||
func (s *Store) listChats(ctx context.Context, actorID string, limit int, after *time.Time, afterID string) ([]Chat, string, error) {
|
||||
sql := `SELECT ` + chatColumns + ` FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1::uuid`
|
||||
args := []any{actorID}
|
||||
if after != nil {
|
||||
sql += ` WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid)`
|
||||
args = append(args, *after, afterID)
|
||||
}
|
||||
sql += ` ORDER BY c.created_at, c.id LIMIT ` + placeholder(len(args)+1)
|
||||
args = append(args, limit+1)
|
||||
rows, err := s.pool.Query(ctx, sql, args...)
|
||||
if err != nil {
|
||||
return nil, "", err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []Chat{}
|
||||
var lastTime time.Time
|
||||
for rows.Next() {
|
||||
c, created, err := scanChat(rows)
|
||||
if err != nil {
|
||||
return nil, "", err
|
||||
}
|
||||
if len(items) == limit { // лишняя строка: следующая страница существует
|
||||
return items, encodeCursor("chats", actorID, lastTime, items[len(items)-1].ID), rows.Err()
|
||||
}
|
||||
items = append(items, c)
|
||||
lastTime = created
|
||||
}
|
||||
return items, "", rows.Err()
|
||||
}
|
||||
|
||||
func placeholder(n int) string { return "$" + itoa(n) }
|
||||
|
||||
// ---- сообщения ----
|
||||
|
||||
func (s *Store) createMessage(ctx context.Context, m Message) (Message, error) {
|
||||
var created time.Time
|
||||
err := s.pool.QueryRow(ctx,
|
||||
`INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1::uuid, $2::uuid, $3::uuid, $4) RETURNING created_at`,
|
||||
m.ID, m.ChatID, m.SenderID, m.Text).Scan(&created)
|
||||
if err != nil {
|
||||
return Message{}, err
|
||||
}
|
||||
m.CreatedAt = formatTime(created)
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (s *Store) listMessages(ctx context.Context, chatID string, limit int, after *time.Time, afterID string) ([]Message, string, error) {
|
||||
sql := `SELECT id::text, chat_id::text, sender_id::text, text, created_at FROM messages WHERE chat_id = $1::uuid`
|
||||
args := []any{chatID}
|
||||
if after != nil {
|
||||
sql += ` AND (created_at, id) > ($2::timestamptz, $3::uuid)`
|
||||
args = append(args, *after, afterID)
|
||||
}
|
||||
sql += ` ORDER BY created_at, id LIMIT ` + placeholder(len(args)+1)
|
||||
args = append(args, limit+1)
|
||||
rows, err := s.pool.Query(ctx, sql, args...)
|
||||
if err != nil {
|
||||
return nil, "", err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []Message{}
|
||||
var lastTime time.Time
|
||||
for rows.Next() {
|
||||
var m Message
|
||||
var created time.Time
|
||||
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &created); err != nil {
|
||||
return nil, "", err
|
||||
}
|
||||
if len(items) == limit {
|
||||
return items, encodeCursor("messages", chatID, lastTime, items[len(items)-1].ID), rows.Err()
|
||||
}
|
||||
m.CreatedAt = formatTime(created)
|
||||
items = append(items, m)
|
||||
lastTime = created
|
||||
}
|
||||
return items, "", rows.Err()
|
||||
}
|
||||
|
||||
// ready: БД отвечает и схема доведена до последней миграции.
|
||||
func (s *Store) ready(ctx context.Context) error {
|
||||
versions := migrationVersions()
|
||||
var n int
|
||||
if err := s.pool.QueryRow(ctx,
|
||||
`SELECT count(*) FROM schema_migrations WHERE version = ANY($1::text[])`, versions).Scan(&n); err != nil {
|
||||
return err
|
||||
}
|
||||
if n != len(versions) {
|
||||
return errors.New("schema is not up to date")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Собственные проверки lab2 поверх публичных (stdlib, Python 3.9+; работают на Windows/Linux).
|
||||
|
||||
python student-tests/extra_checks.py # гонка регистрации, откат чата, auth-негативы
|
||||
python student-tests/extra_checks.py --expiry # истечение сессии; API запущен с SESSION_TTL_SECONDS=2
|
||||
|
||||
Создаёт синтетических пользователей; токены не печатаются. Публичные tests/ не изменяются и не ослабляются.
|
||||
"""
|
||||
import base64
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
|
||||
from client import Client, Failure, arguments, check, run, timestamp # noqa: E402
|
||||
import datetime as dt # noqa: E402
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
return {'Authorization': 'Basic ' + base64.b64encode((username + ':' + password).encode()).decode()}
|
||||
|
||||
|
||||
def register_race(c):
|
||||
"""12 одновременных регистраций одного username: ровно одна 201, остальные 409."""
|
||||
username = 'race_' + uuid.uuid4().hex[:12]
|
||||
body = {'username': username, 'display_name': 'Гонка', 'password': 'Race-password-' + uuid.uuid4().hex}
|
||||
codes, lock = [], threading.Lock()
|
||||
|
||||
def worker():
|
||||
r = c.call('POST', '/api/v1/users', [201, 409], body=body)
|
||||
with lock:
|
||||
codes.append(r['status'])
|
||||
|
||||
threads = [threading.Thread(target=worker) for _ in range(12)]
|
||||
[t.start() for t in threads]
|
||||
[t.join() for t in threads]
|
||||
check(codes.count(201) == 1 and codes.count(409) == 11, 'race: expected one 201 and eleven 409, got %r' % sorted(codes))
|
||||
print('OK регистрация одного username в гонке: 1×201 + 11×409')
|
||||
|
||||
|
||||
def chat_atomicity(c):
|
||||
"""Чат с несуществующим участником: 400 и ни одного «половинчатого» чата у пользователя."""
|
||||
alice = c.user('atom')
|
||||
ghost = str(uuid.uuid4())
|
||||
c.call('POST', '/api/v1/chats', 400, actor=alice, body={'title': 'призрак', 'member_ids': [alice['id'], ghost]})
|
||||
listed = c.call('GET', '/api/v1/chats?limit=100', actor=alice, schema='ChatPage')['json']
|
||||
check(listed['items'] == [], 'failed chat creation left a chat behind')
|
||||
print('OK создание чата с неизвестным участником: 400, чатов нет (атомарность)')
|
||||
|
||||
|
||||
def auth_negatives(c):
|
||||
alice = c.user('neg')
|
||||
reg = alice['registration']
|
||||
# неверный пароль и неизвестный пользователь неразличимы
|
||||
a = c.call('POST', '/api/v1/auth/sessions', 401, headers=basic(reg['username'], 'wrong-password-123'))
|
||||
b = c.call('POST', '/api/v1/auth/sessions', 401, headers=basic('nobody_' + uuid.uuid4().hex[:8], 'wrong-password-123'))
|
||||
check(a['json']['error']['message'] == b['json']['error']['message'], 'login errors reveal whether the user exists')
|
||||
# Bearer вместо Basic и отсутствие заголовка на /auth/sessions
|
||||
c.call('POST', '/api/v1/auth/sessions', 401, actor=alice)
|
||||
c.call('POST', '/api/v1/auth/sessions', 401)
|
||||
# токен выглядит как случайный непрозрачный (>=256 бит), а не как username/UUID
|
||||
token = alice['token']
|
||||
check(len(token) >= 43 and reg['username'] not in token and alice['id'] not in token, 'token is not opaque/random enough')
|
||||
# пароль не возвращается нигде
|
||||
me = c.call('GET', '/api/v1/users/me', actor=alice, schema='User')['json']
|
||||
check('password' not in me and 'password_hash' not in me, 'password data leaked in User')
|
||||
# пароль короче 12 символов и лишние поля — 400
|
||||
c.call('POST', '/api/v1/users', 400, body={'username': 'short_' + uuid.uuid4().hex[:8], 'display_name': 'x', 'password': 'short'})
|
||||
c.call('POST', '/api/v1/users', 400, body={'username': 'extra_' + uuid.uuid4().hex[:8], 'display_name': 'x', 'password': 'long-enough-password', 'is_admin': True})
|
||||
print('OK негативные сценарии аутентификации (401/400, токен непрозрачный)')
|
||||
|
||||
|
||||
def expiry(c):
|
||||
username = 'ttl_' + uuid.uuid4().hex[:12]
|
||||
password = 'Ttl-password-' + uuid.uuid4().hex
|
||||
c.call('POST', '/api/v1/users', 201, body={'username': username, 'display_name': 'TTL', 'password': password}, schema='User')
|
||||
s = c.call('POST', '/api/v1/auth/sessions', 201, headers=basic(username, password), schema='Session')['json']
|
||||
now = dt.datetime.now(dt.timezone.utc)
|
||||
ttl = (timestamp(s['expires_at']) - now).total_seconds()
|
||||
check(ttl <= 30, 'expiry check needs a short TTL: start API with SESSION_TTL_SECONDS=2 (now %.0fs)' % ttl)
|
||||
actor = {'id': s['user']['id'], 'token': s['token']}
|
||||
c.call('GET', '/api/v1/users/me', 200, actor=actor)
|
||||
time.sleep(max(0.0, ttl) + 1.2)
|
||||
c.call('GET', '/api/v1/users/me', 401, actor=actor)
|
||||
c.call('DELETE', '/api/v1/auth/sessions/current', 401, actor=actor)
|
||||
print('OK сессия с TTL≈%.0f с действовала, после истечения — 401' % ttl)
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Extra lab2 checks', lambda p: p.add_argument('--expiry', action='store_true'))
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
if args.expiry:
|
||||
expiry(c)
|
||||
else:
|
||||
register_race(c)
|
||||
chat_atomicity(c)
|
||||
auth_negatives(c)
|
||||
print('PASS')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
Reference in New Issue
Block a user