feat(app) lab2 prepared for mr

This commit is contained in:
imadev
2026-10-23 18:55:20 +03:00
parent 1db3953226
commit f6e74247fd
57 changed files with 2367 additions and 660 deletions
+1
View File
@@ -18,3 +18,4 @@ __pycache__
node_modules
evidence
.DS_Store
app/tmp
+22 -6
View File
@@ -1,11 +1,27 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# compose.yaml reads these values. Only POSTGRES_PASSWORD is a secret.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
DB_POOL_MAX_CONNS=10
# Local PostgreSQL. The API receives a full DATABASE_URL built by compose.yaml.
POSTGRES_USER=messenger
POSTGRES_PASSWORD=replace-with-a-local-password
POSTGRES_DB=messenger
# Host port for the API. 8081 is used only by the optional short-TTL check.
APP_PORT_PUBLISH=8080
APP_SHORT_TTL_PORT=8081
# Redis is the session store (lab 2 grade 4); PostgreSQL stays the source of
# truth for users, chats, memberships and messages.
SESSION_STORE=redis
# Optional overrides instead of the compose-generated URLs. A *_FILE value is
# read from a file, which is how Docker/Compose secrets are usually mounted.
# DATABASE_URL=postgres://messenger:password@localhost:5432/messenger?sslmode=disable
# DATABASE_URL_FILE=/run/secrets/database_url
# CACHE_URL=redis://localhost:6379/0
# CACHE_URL_FILE=/run/secrets/cache_url
+4
View File
@@ -30,3 +30,7 @@ coverage/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
# Local application builds
app/tmp/
app/server
+20
View File
@@ -0,0 +1,20 @@
# syntax=docker/dockerfile:1.7
# AGENT: Two-stage build. The final image contains only the static binary and a
# CA bundle, runs as a non-root user and keeps the server as PID 1 for signals.
FROM golang:1.27.1-alpine AS build
WORKDIR /src
COPY app/go.mod app/go.sum ./
RUN go mod download
COPY app/ ./
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/server ./cmd/server
FROM alpine:3.22
RUN addgroup -S -g 10001 app && adduser -S -u 10001 -G app app
COPY --from=build /out/server /usr/local/bin/server
USER app
EXPOSE 8080
ENTRYPOINT ["/usr/local/bin/server"]
+136 -16
View File
@@ -1,37 +1,157 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: заполнить перед сдачей (ФИО, группа).
- Целевая оценка: **4** (уровень 3 полностью и все пункты уровня 4). Трек уровня 5 не заявлен.
- Commit/PR: локальный тег `lab2-green`; актуальный хеш — `git log -1 --oneline`.
- Использованные источники, библиотеки и помощь ИИ: Go 1.27.1, Fiber v3.5.0, pgx v5.11.0, go-redis v9.23.0, Argon2id из `golang.org/x/crypto`; PostgreSQL 16.10, Redis 7.4.7. ИИ-ассистент использован для черновика кода, миграций, скриптов и этого отчёта; все заявленные результаты получены командами из таблицы ниже и сохранены в `evidence/`.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требования: Docker с Compose v2, свободный порт `8080` (и `8081` только для проверки короткого TTL). Проверено на Docker 29.3.0 и Compose 5.6.0; для приложения нужен Go только при локальной сборке, в Compose сборка идёт внутри образа `golang:1.27.1-alpine`.
```sh
git clone <repo> && cd mtusi2026lab2
cp .env.example .env
# заменить POSTGRES_PASSWORD на локальный пароль; .env не коммитится
docker compose --env-file .env up -d --build --wait
curl -i http://localhost:8080/health/ready # ожидается 200 {"status":"ok"}
make check
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
Если API запущен на другом хосте (например, Docker daemon на хосте, а тесты в отдельной песочнице), адрес передаётся явно, менять `Makefile` не нужно:
```sh
make test BASE_URL=http://<host>:8080
make test-persistence BASE_URL=http://<host>:8080 ACTION_SCRIPT=scripts/restart.sh
```
Для проверки истечения с коротким TTL поднимается второй экземпляр API с тем же PostgreSQL и Redis:
```sh
docker compose --env-file .env --profile checks up -d --wait api-short-ttl
python3 scripts/grade4_checks.py \
--base-url http://localhost:8080 \
--short-ttl-url http://localhost:8081
```
Сборка и схема:
- API собирается в два этапа (`Dockerfile`): статический бинарник на `golang:1.27.1-alpine`, запуск от непривилегированного пользователя на `alpine:3.22`.
- Миграции встроены в бинарник и выполняются при старте API под `pg_advisory_lock`; версия пишется в `schema_migrations`. Повторный запуск не дублирует данные, повторное применение с нуля проверено удалением собственных volumes.
- Compose создаёт named volumes `mtusi2026lab2_pgdata` и `mtusi2026lab2_redisdata`. Секреты и volumes не в Git: `.env` и `volumes/` в `.gitignore`, `.env.example` содержит только заполнители.
Остановка и удаление учебных данных:
```sh
docker compose --env-file .env down # остановить, volumes сохранить
docker compose --env-file .env down -v # осознанно удалить синтетические данные
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```text
клиент --HTTP--> API (Go/Fiber) --SQL--> PostgreSQL 16
\--RESP--> Redis 7 (sessions, AOF + named volume)
```
- **Источник истины для бизнес-данных** — PostgreSQL: `users`, `chats`, `chat_members`, `messages`. В памяти процесса нет пользовательских данных, поэтому API можно перезапускать и (в следующих лабах) реплицировать без потери подтверждённых записей.
- **Источник истины для сессий** — Redis. API не хранит сессии локально. Токен — 32 случайных байта (`crypto/rand`, 256 бит), в Redis лежит только `SHA-256(token) -> user_id` с TTL. По дампу Redis нельзя восстановить действующий bearer-токен.
- **Срок жизни сессии** задаёт `SESSION_TTL_SECONDS` (по умолчанию 3600). При каждом запросе TTL не продлевается. `DELETE /auth/sessions/current` удаляет ключ текущего токена; повторный запрос с ним получает `401`.
- **Перезапуск Redis.** Включён AOF (`appendonly yes`, `appendfsync everysec`) и named volume. Абсолютные сроки жизни ключей сохраняются в AOF, поэтому после graceful-перезапуска действующие сессии остаются валидными, а истёкшие — нет. При жёстком `kill -9` возможна потеря последней секунды записей (не более, чем допускает `everysec`); это ограничение указано в разделе «Ограничения». Если удалить volume Redis, сессии пропадут — приложение не подменяет их анонимным пользователем.
- **Пароли.** Argon2id: `m=65536 KiB, t=2, p=4`, случайная соль 16 байт, сравнение в постоянное время. Хеш и параметры хранятся в `password_hash`; в JSON-ответах поля нет. Argon2id выбран вместо bcrypt, потому что контракт разрешает пароль до 128 Unicode code points, а bcrypt молча обрезает длинные пароли.
- **Basic только на входе.** `POST /api/v1/auth/sessions` — единственный endpoint с Basic. Все бизнес-endpoint принимают только `Authorization: Bearer`. `X-User-Id` нигде не читается и не влияет на владельца сессии.
- **Транзакционные границы.** Создание пользователя — один `INSERT`; уникальность username обеспечивает constraint `users_username_key`, гонка двух регистраций даёт один `201` и остальные `409`. Создание чата вместе со всеми `chat_members` выполняется в одной транзакции: неизвестный участник откатывает и чат, и членство. Отправка сообщения — один `INSERT ... SELECT ... WHERE EXISTS (членство)`, поэтому проверка доступа и запись атомарны.
- **Ключи и индексы.** Первичные ключи UUID, внешние ключи с `ON DELETE RESTRICT/CASCADE`, уникальный индекс по `users.username`. История использует keyset-пагинацию по `(created_at, id)` и индекс `messages_chat_created_id_idx (chat_id, created_at, id)`; запрос не делает `OFFSET` и не читает историю с начала.
- **Пулы и таймауты.** `pgxpool`: не более 10 соединений (`DB_POOL_MAX_CONNS`), `MinConns=1`, connect timeout 3 с, таймаут запроса 5 с. Redis: pool 10, dial/read/write 2 с, без автоматических повторов. HTTP: read/write 10 с, idle 60 с, body limit 1 МиБ. Все обращения к зависимостям ограничены контекстом.
- **Ошибки и health.** Все ошибки идут через `common.AppError`/`SendError` и сохраняют форму `{"error":{"code","message","request_id"}}`; `X-Request-Id` выставляет middleware на каждый ответ, включая 404, 401, 204 и health. `/health/live` отвечает 200, пока жив процесс. `/health/ready` проверяет PostgreSQL и Redis и возвращает 503 в общей форме ошибки, если хотя бы один недоступен. При недоступном Redis защищённый запрос получает ограниченный `503 unavailable`, а не `401` и не доступ без пользователя.
Переменные окружения:
| Переменная | Назначение | Значение по умолчанию |
| --- | --- | --- |
| `APP_HOST`, `APP_PORT` | адрес HTTP-сервера | `0.0.0.0`, `8080` |
| `SESSION_TTL_SECONDS` | TTL сессии в секундах | `3600` |
| `DATABASE_URL` / `DATABASE_URL_FILE` | строка подключения к PostgreSQL | обязательна |
| `CACHE_URL` / `CACHE_URL_FILE` | URL Redis | обязательна |
| `SESSION_STORE` | выбранное хранилище сессий, допускается только `redis` | `redis` |
| `DB_POOL_MAX_CONNS` | максимум соединений pgxpool | `10` |
| `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB` | параметры локального контейнера PostgreSQL; Compose собирает из них `DATABASE_URL` | заполняются в `.env` |
| `APP_PORT_PUBLISH`, `APP_SHORT_TTL_PORT` | опубликованные порты основного API и проверки TTL | `8080`, `8081` |
## Доказательства критериев
Все команды выполнялись из корня репозитория; для стенда в этой среде использовался адрес `http://172.18.0.1:8080` (sandbox → опубликованный порт Docker-хоста). В обычном локальном запуске достаточно `http://localhost:8080`, поэтому `BASE_URL` в примерах ниже — параметр, а не изменённый default.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Структура и JSON репозитория | `make check` | `PASS: offline skeleton structure...` | `evidence/01-make-check.txt` |
| Сборка, vet, unit-тесты | `cd app && go build ./... && go vet ./... && go test ./...` | сборка без ошибок, тесты Argon2id и cursor проходят | `evidence/02-go-build-test.txt` |
| Полная OpenAPI/JSON-Schema валидация | `make validate PYTHON=.venv/bin/python` | `PASS: full OpenAPI 3.1...` | `evidence/03-make-validate.txt` |
| Compose воспроизводим | `docker compose --env-file .env config --quiet` | код 0; services `redis postgres api`, volumes `pgdata redisdata` | `evidence/04-compose.txt` |
| Публичный smoke | `make test BASE_URL=...` | `PASS: lab2 public API scenario` | `evidence/05-smoke.txt` |
| PostgreSQL: ключи, FK, уникальность, check-ограничения | `\d users`, `\d chats`, `\d chat_members`, `\d messages` | PK/FK/unique/check присутствуют | `evidence/11-schema.txt` |
| Миграции с нуля и повторный запуск | `down -v` только для собственного проекта, затем `up`; перезапуски | `schema_migrations` содержит одну версию; данные не дублируются | `evidence/04-compose.txt`, `evidence/11-schema.txt`, `evidence/06-persistence.txt` |
| Атомарное создание чата | `python3 scripts/grade4_checks.py` | неизвестный member → 400, частичного чата нет | `evidence/07-grade4-checks.txt` |
| Пароли — password KDF, не в ответах/logs | unit-тест + smoke + код | Argon2id, поле `password_hash` только в БД | `evidence/02-go-build-test.txt`, `evidence/05-smoke.txt` |
| Basic только для сессии, Bearer для бизнеса | smoke | Basic на `/users/me` → 401; Basic на `/auth/sessions` → 201 | `evidence/05-smoke.txt` |
| `X-User-Id` игнорируется | `grade4_checks.py` | заголовок не меняет пользователя и сам по себе не даёт доступ | `evidence/07-grade4-checks.txt` |
| TTL, logout, неверный пароль | `grade4_checks.py` (TTL=2 с) | истечение → 401; logout → 204, повтор → 401; неверный пароль → 401 + Basic challenge | `evidence/07-grade4-checks.txt` |
| Переживание рестарта API и хранилищ с volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS`, старый токен читает те же данные; `StartedAt` всех трёх контейнеров изменился, volumes на месте | `evidence/06-persistence.txt` |
| Redis/Valkey реально используется для сессий с TTL | compose + `grade4_checks.py` | ключи с TTL, AOF-файлы в named volume; после остановки/старта Redis старый токен работает | `evidence/06-persistence.txt`, `evidence/07-grade4-checks.txt`, `evidence/10-final-state.txt` |
| Параметризованные запросы, bounded pool, таймауты | ревью `app/internal/store/store.go`, `app/internal/session/store.go`, `app/internal/config/config.go` | `$1..$n`, `MaxConns=10`, контекстные таймауты | `evidence/02-go-build-test.txt` + исходники |
| Гонка регистрации username | `grade4_checks.py` | 12 одновременных запросов → один `201`, одиннадцать `409` | `evidence/07-grade4-checks.txt` |
| Rollback составной операции | `grade4_checks.py` | после ошибки чат с тем же title отсутствует в списке | `evidence/07-grade4-checks.txt` |
| Keyset-пагинация и индекс, доказательство на ≥10 000 сообщений | `./scripts/seed_and_explain.sh` | `Index Scan using messages_chat_created_id_idx`, 5–6 shared buffers, ~0,09–0,10 мс | `evidence/08-explain.txt` |
| Автопроверки expiry/logout/wrong password/Redis/PostgreSQL outage | `grade4_checks.py` | все пункты `PASS` | `evidence/07-grade4-checks.txt` |
| Redis недоступен: live 200, ready 503, protected 503 | `grade4_checks.py` (stop/start Redis) | live=200, ready=503, protected=503; после старта тот же токен и сообщение целы | `evidence/07-grade4-checks.txt` |
| PostgreSQL недоступен: live 200, ready 503, protected 503 | `grade4_checks.py` (stop/start PostgreSQL) | live=200, ready=503, protected=503; сессия и данные пережили отказ | `evidence/07-grade4-checks.txt` |
| Форма ошибок и `X-Request-Id` во всех ответах | проверки `tests/client.py` внутри smoke/grade4 | каждый ответ содержит непустой `X-Request-Id`, `request_id` совпадает с заголовком | `evidence/05-smoke.txt`, `evidence/07-grade4-checks.txt` |
| Конфигурация и версии зафиксированы | `evidence/00-environment.txt`, `compose.yaml`, `Dockerfile` | образы `postgres:16.10-alpine`, `redis:7.4.7-alpine`, `golang:1.27.1-alpine`, `alpine:3.22` | `evidence/00-environment.txt` |
| Секреты и volumes не в Git | `git status --short`, `git ls-files` | `.env` и volumes отсутствуют в индексе | `evidence/12-git-hygiene.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Аппаратные условия: 4 vCPU, 7,5 GiB RAM, Docker daemon на хосте, один экземпляр API и по одному контейнеру PostgreSQL/Redis. Все цифры — локальный учебный стенд, не production-измерение.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
### План запроса истории
В отдельном чате создано ровно 10 000 синтетических сообщений (`scripts/seed_10k.sql`). Запрос повторяет SQL API: `WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT 51`.
| Страница | План | Buffers | Execution time |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Первая (cursor в начале) | `Index Scan using messages_chat_created_id_idx` | shared hit=6 | 0,104 мс |
| Глубокая (cursor на 5000-й секунде) | `Index Scan using messages_chat_created_id_idx` | shared hit=5 | 0,087 мс |
План не зависит от номера страницы: позиция ищется по индексу, а не перебором предыдущих строк. Сырой вывод — `evidence/08-explain.txt`.
### Нагрузка
`tests/load.py` — closed-loop генератор POST-сообщений (client-bound, без retry), поэтому это не доказательство максимальной пропускной способности.
| Профиль | Успешных | Ошибок | RPS | p50 / p95 / p99 |
| --- | --- | --- | --- | --- |
| 10 с, concurrency 4, один API | 8854 | 0 | 877,6 | 4,06 / 7,84 / 10,65 мс |
Сырые метрики — `evidence/load.json`, команда и вывод — `evidence/09-load.txt`.
### Отказы зависимостей
| Воздействие | Что ожидали | Что наблюдали | Восстановление / потери |
| --- | --- | --- | --- |
| `docker compose stop redis` | `/health/live` 200; `/health/ready` 503; защищённый запрос — ограниченный 503, не анонимный доступ | именно так; обнаружение отказа за 4,4 с (включая таймауты Redis) | `start redis` → готовность за 4,0 с; старый токен и подтверждённое сообщение на месте; потерь нет |
| `docker compose stop postgres` | то же; сессия остаётся в Redis | live=200, ready=503, protected=503; обнаружение за 2,8 с | `start postgres` → готовность за 0,9 с; старый токен и сообщение на месте; потерь нет |
| `make test-persistence` (рестарт API + PostgreSQL + Redis) | тот же токен, те же данные | PASS; `StartedAt` всех контейнеров изменился; volumes сохранены | данные и сессия сохранены |
| `docker compose down -v` (только для собственного стенда) | чистая БД, миграции с нуля | API стартует, `schema_migrations` = одна строка | данные удалены осознанно |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один экземпляр API и один Redis; балансировщик, реплики и failover — lab 3+, здесь не реализованы. Redis не кластер, поэтому потеря его volume означает потерю сессий (бизнес-данные в PostgreSQL при этом целы).
- AOF с `appendfsync everysec`: при аварийном убийстве процесса возможна потеря до ~1 секунды последних операций с сессиями. Graceful-перезапуск, который использует `scripts/restart.sh`, проходит без потерь.
- Время сообщения хранится с точностью до секунды (как в lab 1), поэтому сообщения одной секунды упорядочиваются по UUID. Это согласовано с контрактом: курсор — `(created_at, id)`, а при конкурентных вставках возможна перестановка внутри секунды; полной snapshot-изоляции между HTTP-запросами контракт не требует.
- Список `member_ids` в ответе чата упорядочен по UUID, а не по порядку запроса; состав участников от этого не меняется. Порядок чатов и сообщений, который важен контракту, соблюдается.
- Нет rate limiting, вложений, редактирования/удаления сообщений, смены пароля и публичного поиска пользователей — это не входит в lab 2.
- Нагрузочный отчёт ограничен closed-loop клиентом и не является измерением ёмкости. Для lab 5 понадобится открытый генератор и отдельная методика.
- В отчёте не раскрываются токены, пароли и содержимое `.env`; в `evidence/` сохранены только агрегаты и коды ответов.
Executable
+59
View File
@@ -0,0 +1,59 @@
#:schema https://json.schemastore.org/any.json
env_files = []
root = "."
testdata_dir = "testdata"
tmp_dir = "tmp"
[build]
args_bin = []
bin = "./tmp/main"
cmd = "go build -o ./tmp/main ./cmd/server/"
delay = 1000
entrypoint = ["./tmp/main"]
exclude_dir = ["assets", "tmp", "vendor", "testdata"]
exclude_file = []
exclude_regex = ["_test.go"]
exclude_unchanged = false
follow_symlink = false
full_bin = ""
ignore_dangerous_root_dir = false
include_dir = []
include_ext = ["go", "tpl", "tmpl", "html"]
include_file = []
kill_delay = "0s"
log = "build-errors.log"
poll = false
poll_interval = 0
post_cmd = []
pre_cmd = []
rerun = false
rerun_delay = 500
send_interrupt = false
stop_on_error = false
[color]
app = ""
build = "yellow"
main = "magenta"
mode = ""
runner = "green"
watcher = "cyan"
[log]
main_only = false
silent = false
time = false
[misc]
clean_on_exit = false
[proxy]
app_port = 0
app_start_timeout = 0
enabled = false
proxy_port = 0
[screen]
clear_on_rebuild = false
keep_scroll = true
+43 -39
View File
@@ -2,60 +2,64 @@ package main
import (
"context"
"os"
"log"
"os/signal"
"syscall"
"time"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal"
"github.com/gofiber/fiber/v3/log"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/config"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/database"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/session"
)
func main() {
log.SetOutput(os.Stdout)
log.SetLevel(log.LevelDebug)
app := internal.GetApp()
host := os.Getenv("APP_HOST")
port := os.Getenv("APP_PORT")
if port == "" {
port = "8080"
cfg, err := config.Load()
if err != nil {
log.Fatalf("configuration: %v", err)
}
if host == "" {
host = "0.0.0.0"
rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
pool, err := database.Connect(rootCtx, cfg.DatabaseURL, cfg.DBMaxConns, cfg.StartupWait)
if err != nil {
log.Fatalf("database: %v", err)
}
defer pool.Close()
addr := host + ":" + port
migrateCtx, cancelMigrate := context.WithTimeout(rootCtx, 60*time.Second)
if err = database.Migrate(migrateCtx, pool); err != nil {
cancelMigrate()
log.Fatalf("migrations: %v", err)
}
cancelMigrate()
sessions, err := session.New(cfg.CacheURL, cfg.SessionTTL, cfg.RedisTimeout)
if err != nil {
log.Fatalf("session store: %v", err)
}
defer sessions.Close()
app := internal.New(cfg, pool, sessions)
addr := cfg.Host + ":" + cfg.Port
listenErr := make(chan error, 1)
go func() {
if err := app.Listen(addr); err != nil {
log.Fatalf("Server error: %v", err)
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGTERM)
<-quit
ctx, cancel := context.WithTimeout(
context.Background(), 10*time.Second)
defer cancel()
log.Info("Received SIGTERM, shutting down...")
internal.SignalGracefulShutdown()
shutdownComplete := make(chan error, 1)
go func() {
shutdownComplete <- app.Shutdown()
listenErr <- app.Listen(addr)
}()
select {
case err := <-shutdownComplete:
log.Errorf("Shutdown error: %v", err)
case <-ctx.Done():
log.Info("Server stopped gracefully")
case err = <-listenErr:
if err != nil {
log.Fatalf("server: %v", err)
}
case <-rootCtx.Done():
}
log.Printf("shutting down")
internal.SignalGracefulShutdown()
if err = app.ShutdownWithTimeout(10 * time.Second); err != nil {
log.Printf("shutdown: %v", err)
}
}
+12 -3
View File
@@ -1,18 +1,25 @@
module gitflic.ru/project/bulla-max/mtusi2026lab1
module gitflic.ru/project/bulla-max/mtusi2026lab2
go 1.27.1
require (
github.com/go-playground/validator v9.31.0+incompatible
github.com/gofiber/fiber/v3 v3.5.0
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.11.0
github.com/redis/go-redis/v9 v9.23.0
golang.org/x/crypto v0.57.0
)
require (
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.2 // indirect
github.com/go-playground/validator v9.31.0+incompatible // indirect
github.com/gofiber/schema v1.8.8 // indirect
github.com/gofiber/utils/v2 v2.6.1 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/klauspost/compress v1.20.1 // indirect
github.com/leodido/go-urn v1.5.0 // indirect
github.com/mattn/go-colorable v0.1.15 // indirect
@@ -22,9 +29,11 @@ require (
github.com/tinylib/msgp v1.6.5 // indirect
github.com/valyala/bytebufferpool v1.0.0 // indirect
github.com/valyala/fasthttp v1.74.0 // indirect
golang.org/x/crypto v0.57.0 // indirect
go.uber.org/atomic v1.12.0 // indirect
golang.org/x/net v0.59.0 // indirect
golang.org/x/sync v0.23.0 // indirect
golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.42.0 // indirect
golang.org/x/tools v0.50.0 // indirect
gopkg.in/go-playground/assert.v1 v1.2.1 // indirect
)
+33
View File
@@ -1,3 +1,10 @@
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/fxamacker/cbor/v2 v2.9.4 h1:xwjVlxEMR3S605oUlgBjKLTTeGFciYPGYCtF/35LKGo=
github.com/fxamacker/cbor/v2 v2.9.4/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
@@ -14,8 +21,18 @@ github.com/gofiber/utils/v2 v2.6.1 h1:x3zsS/oUQz0ia2Zx8XXtG/7naR5a+/95FRO8mwQ5QQ
github.com/gofiber/utils/v2 v2.6.1/go.mod h1:tc9KqdRAQZRD/u0mN2d1ZHROGheSZv+0FcC9cg5OEdw=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg=
github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/klauspost/compress v1.20.1 h1:T7kKElXUMXrUJ2E9QhQhxFtcK5rPyLdsGZvdbLMPdiQ=
github.com/klauspost/compress v1.20.1/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
github.com/leodido/go-urn v1.5.0 h1:pLqT2kq1zpHW/1D18QMjMpdtX7cekxqtJJjg5ANyWw0=
github.com/leodido/go-urn v1.5.0/go.mod h1:9BORnCDhdPBJNDEX+w1bJisa8yOKYi116VeO96s4ifE=
github.com/mattn/go-colorable v0.1.15 h1:+u9SLTRGnXv73cEsnsmoZBom+dMU88B2M0aDcWy0/jY=
@@ -26,8 +43,14 @@ github.com/molecule-man/go-brrr v1.1.1 h1:KYwusQhjtV3smALnhmafZf4OBrh7vP4p8O47Dy
github.com/molecule-man/go-brrr v1.1.1/go.mod h1:7ybW6/7gA3oKY45jOfVNjSJDtrr6ea4tzbsTkjmQDC4=
github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM=
github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s=
github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0=
github.com/shamaton/msgpack/v3 v3.2.3 h1:0r0aZtrXDFOPpwWJTEOpFq+Ih/JmMLm0pqLN5mSilrw=
github.com/shamaton/msgpack/v3 v3.2.3/go.mod h1:sgBYvEiyz8JR1NC3yGRoPVME9xXovpnh3l/plW1nfRo=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
github.com/tinylib/msgp v1.6.5 h1:iAH6XTP7BpzErjBZlujJQXxA+GmRi2YWs6M4KdLtNbE=
@@ -38,15 +61,25 @@ github.com/valyala/fasthttp v1.74.0 h1:wMS9fnO2QTALozYx5pId2Vi7ZwU/epUkY8i/KPWCH
github.com/valyala/fasthttp v1.74.0/go.mod h1:3ARmLamUcw7ElxVtC8PXaGzQ6VEuvnetlkrwIklQBSE=
github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE=
go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk=
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
golang.org/x/net v0.59.0 h1:5zfYln+w5XCxwrnMMJPufRgNoXEaGxl0wo5GqPXyues=
golang.org/x/net v0.59.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
golang.org/x/tools v0.50.0 h1:c2ifzfcuY7L90lZ2aKd8S4K2NpASF08SZx9ZuJkHmSU=
golang.org/x/tools v0.50.0/go.mod h1:7ulVMw3831Mwi5EZD6RomGyffr4VFjuNYXf2BbCEAV0=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXadIrXTM=
gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+29 -43
View File
@@ -2,59 +2,43 @@ package internal
import (
"errors"
"time"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/chats"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/health"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/messages"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/storage"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/users"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/auth"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/chats"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/config"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/health"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/messages"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/session"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/users"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/recover"
"github.com/gofiber/fiber/v3/middleware/requestid"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
)
func SignalGracefulShutdown() {
health.SignalShutdown()
}
func authMiddleware(c fiber.Ctx) error {
userIDStr := c.Get("X-User-Id")
if userIDStr == "" {
return common.SendError(c, fiber.StatusUnauthorized,
common.ErrorCodeUnauthorized, "X-User-Id header is required")
}
func New(cfg config.Config, pool *pgxpool.Pool, sessions *session.Store) *fiber.App {
st := store.New(pool, cfg.DBTimeout)
userID, err := uuid.Parse(userIDStr)
if err != nil {
return common.SendError(c, fiber.StatusBadRequest,
common.ErrorCodeInvalidRequest, "X-User-Id must be a valid UUID")
}
var exists bool
err = storage.GlobalStore.View(func(tx storage.ReadOnlyTx) error {
_, exists = tx.GetUser(userID)
return nil
})
if err != nil || !exists {
return common.SendError(c, fiber.StatusUnauthorized,
common.ErrorCodeUnauthorized, "user not found")
}
c.Locals("userID", userID)
return c.Next()
}
func GetApp() *fiber.App {
app := fiber.New(fiber.Config{
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: 60 * time.Second,
BodyLimit: 1 * 1024 * 1024,
ErrorHandler: func(c fiber.Ctx, err error) error {
if appErr, ok := errors.AsType[*common.AppError](err); ok {
var appErr *common.AppError
if errors.As(err, &appErr) {
return common.SendError(c, appErr.Status, appErr.Code, appErr.Message)
}
if fiberErr, ok := errors.AsType[*fiber.Error](err); ok {
var fiberErr *fiber.Error
if errors.As(err, &fiberErr) {
return common.SendError(c, fiberErr.Code,
common.ErrorCodeFromStatus(fiberErr.Code), fiberErr.Message)
}
@@ -67,16 +51,18 @@ func GetApp() *fiber.App {
app.Use(recover.New())
app.Use(requestid.New())
health.RegisterRoutes(app.Group("/health"))
health.RegisterRoutes(app.Group("/health"), st, sessions)
api := app.Group("/api/v1")
users.RegisterPublicRoutes(api)
users.RegisterPublicRoutes(api, st)
auth.RegisterPublicRoutes(api, st, sessions)
protected := api.Group("")
protected.Use(authMiddleware)
users.RegisterRoutes(protected)
chats.RegisterRoutes(protected)
messages.RegisterRoutes(protected)
protected.Use(auth.BearerAuth(sessions))
auth.RegisterRoutes(protected, st, sessions)
users.RegisterRoutes(protected, st)
chats.RegisterRoutes(protected, st)
messages.RegisterRoutes(protected, st)
return app
}
+132
View File
@@ -0,0 +1,132 @@
package auth
import (
"encoding/base64"
"errors"
"strings"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/model"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/session"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/log"
)
const basicChallenge = `Basic realm="messenger", charset="UTF-8"`
const bearerChallenge = `Bearer realm="messenger"`
type Handler struct {
store *store.Store
sessions *session.Store
}
func NewHandler(st *store.Store, sessions *session.Store) *Handler {
return &Handler{store: st, sessions: sessions}
}
// AGENT: CreateSession is the only endpoint that accepts Basic auth. It reads
// no JSON body and returns the same 401 for an unknown user and a wrong
// password, so the response does not reveal which usernames exist.
func (h *Handler) CreateSession(c fiber.Ctx) error {
username, password, ok := parseBasic(c.Get(fiber.HeaderAuthorization))
if !ok {
return common.SendChallenge(c, basicChallenge, "invalid credentials")
}
user, err := h.store.GetUserByUsername(c.Context(), username)
if err != nil {
if common.IsCode(err, common.ErrorCodeNotFound) {
return common.SendChallenge(c, basicChallenge, "invalid credentials")
}
return common.SendAppError(c, err)
}
valid, err := VerifyPassword(user.PasswordHash, password)
if err != nil || !valid {
return common.SendChallenge(c, basicChallenge, "invalid credentials")
}
token, expiresAt, err := h.sessions.Create(c.Context(), user.ID)
if err != nil {
log.Errorf("create session: %v", err)
return common.SendError(c, fiber.StatusServiceUnavailable,
common.ErrorCodeUnavailable, "session store unavailable")
}
return c.Status(fiber.StatusCreated).JSON(model.Session{
Token: token,
TokenType: "Bearer",
ExpiresAt: common.RFCFormTime(expiresAt),
User: user,
})
}
// RevokeSession deletes the current token. The middleware has already proven
// that the token exists, so a repeated DELETE is a 401, not a 204.
func (h *Handler) RevokeSession(c fiber.Ctx) error {
token, _ := c.Locals(sessionTokenLocal).(string)
if token == "" {
return common.SendChallenge(c, bearerChallenge, "authentication required")
}
if err := h.sessions.Revoke(c.Context(), token); err != nil {
log.Errorf("revoke session: %v", err)
return common.SendError(c, fiber.StatusServiceUnavailable,
common.ErrorCodeUnavailable, "session store unavailable")
}
return c.SendStatus(fiber.StatusNoContent)
}
const sessionTokenLocal = "sessionToken"
// BearerAuth accepts only an opaque Bearer token. X-User-Id is deliberately
// never read: with lab 2 it can neither create nor override an identity.
func BearerAuth(sessions *session.Store) fiber.Handler {
return func(c fiber.Ctx) error {
header := strings.TrimSpace(c.Get(fiber.HeaderAuthorization))
scheme, token, found := strings.Cut(header, " ")
token = strings.TrimSpace(token)
if !found || !strings.EqualFold(scheme, "Bearer") || token == "" || strings.ContainsAny(token, " \t") {
return common.SendChallenge(c, bearerChallenge, "authentication required")
}
userID, err := sessions.Lookup(c.Context(), token)
if err != nil {
if errors.Is(err, session.ErrNotFound) {
return common.SendChallenge(c, bearerChallenge, "session expired or revoked")
}
// AGENT: A dead Redis must not degrade to "anonymous allowed".
// Protected calls get a bounded 503 instead of a 401 or a bypass.
log.Errorf("session lookup: %v", err)
return common.SendError(c, fiber.StatusServiceUnavailable,
common.ErrorCodeUnavailable, "session store unavailable")
}
c.Locals("userID", userID)
c.Locals(sessionTokenLocal, token)
return c.Next()
}
}
func parseBasic(header string) (string, string, bool) {
scheme, encoded, found := strings.Cut(strings.TrimSpace(header), " ")
if !found || !strings.EqualFold(scheme, "Basic") || encoded == "" {
return "", "", false
}
decoded, err := base64.StdEncoding.DecodeString(encoded)
if err != nil {
if decoded, err = base64.RawStdEncoding.DecodeString(encoded); err != nil {
return "", "", false
}
}
// RFC 7617: split at the first colon; a colon is legal inside the password.
username, password, found := strings.Cut(string(decoded), ":")
if !found || username == "" || password == "" {
return "", "", false
}
return username, password, true
}
+72
View File
@@ -0,0 +1,72 @@
// AGENT: Argon2id is used instead of bcrypt because the contract allows 128
// Unicode code points and bcrypt silently truncates at 72 bytes. Salt and
// parameters are stored inside the encoded hash string.
package auth
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
const (
argonMemory = 64 * 1024
argonIterations = 2
argonParallelism = 4
argonKeyLength = 32
argonSaltLength = 16
)
var ErrInvalidHash = errors.New("invalid password hash")
func HashPassword(password string) (string, error) {
salt := make([]byte, argonSaltLength)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("generate salt: %w", err)
}
key := argon2.IDKey([]byte(password), salt, argonIterations, argonMemory, argonParallelism, argonKeyLength)
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version, argonMemory, argonIterations, argonParallelism,
base64.RawStdEncoding.EncodeToString(salt),
base64.RawStdEncoding.EncodeToString(key)), nil
}
// VerifyPassword recomputes the digest with the stored parameters and compares
// in constant time.
func VerifyPassword(encoded, password string) (bool, error) {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return false, ErrInvalidHash
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || version != argon2.Version {
return false, ErrInvalidHash
}
var memory uint32
var iterations uint32
var parallelism uint8
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, &parallelism); err != nil {
return false, ErrInvalidHash
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return false, ErrInvalidHash
}
expected, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return false, ErrInvalidHash
}
actual := argon2.IDKey([]byte(password), salt, iterations, memory, parallelism, uint32(len(expected)))
return subtle.ConstantTimeCompare(actual, expected) == 1, nil
}
+46
View File
@@ -0,0 +1,46 @@
package auth
import (
"strings"
"testing"
)
func TestPasswordRoundTripPreservesFullRange(t *testing.T) {
passwords := []string{
"simple-password-123",
"colon:inside:password",
"пароль-с-кириллицей-12",
strings.Repeat("😀", 128),
}
for _, password := range passwords {
hash, err := HashPassword(password)
if err != nil {
t.Fatalf("HashPassword: %v", err)
}
ok, err := VerifyPassword(hash, password)
if err != nil || !ok {
t.Fatalf("VerifyPassword rejected the correct password (ok=%v err=%v)", ok, err)
}
ok, err = VerifyPassword(hash, password+"x")
if err != nil || ok {
t.Fatalf("VerifyPassword accepted a different password (ok=%v err=%v)", ok, err)
}
}
}
func TestPasswordHashIsSalted(t *testing.T) {
first, err := HashPassword("same-password-123")
if err != nil {
t.Fatal(err)
}
second, err := HashPassword("same-password-123")
if err != nil {
t.Fatal(err)
}
if first == second {
t.Fatal("two hashes of the same password are identical")
}
if _, err := VerifyPassword("not-a-hash", "same-password-123"); err == nil {
t.Fatal("invalid encoded hash was accepted")
}
}
+17
View File
@@ -0,0 +1,17 @@
package auth
import (
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/session"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
)
func RegisterPublicRoutes(router fiber.Router, st *store.Store, sessions *session.Store) {
handler := NewHandler(st, sessions)
router.Post("/auth/sessions", handler.CreateSession)
}
func RegisterRoutes(router fiber.Router, st *store.Store, sessions *session.Store) {
handler := NewHandler(st, sessions)
router.Delete("/auth/sessions/current", handler.RevokeSession)
}
-9
View File
@@ -1,9 +0,0 @@
package chats
import "gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
var (
ErrChatNotFound = common.NotFound("chat not found")
ErrInvalidChatID = common.BadRequest("invalid chat_id format")
ErrMemberNotFound = common.BadRequest("member_id refers to non-existent user")
)
+24 -44
View File
@@ -1,13 +1,26 @@
package chats
import (
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/storage"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
"github.com/google/uuid"
)
func createChat(c fiber.Ctx) error {
type Handler struct {
store *store.Store
}
func NewHandler(st *store.Store) *Handler {
return &Handler{store: st}
}
type CreateChatRequest struct {
Title string `json:"title" validate:"required"`
MemberIDs []uuid.UUID `json:"member_ids" validate:"required"`
}
func (h *Handler) CreateChat(c fiber.Ctx) error {
userID := c.Locals("userID").(uuid.UUID)
var req CreateChatRequest
@@ -18,24 +31,11 @@ func createChat(c fiber.Ctx) error {
if msg := common.ValidateChatTitle(req.Title); msg != "" {
return common.SendError(c, fiber.StatusBadRequest, common.ErrorCodeInvalidRequest, msg)
}
if msg := common.ValidateMemberIDs(req.MemberIDs, userID); msg != "" {
return common.SendError(c, fiber.StatusBadRequest, common.ErrorCodeInvalidRequest, msg)
}
var chat Chat
err := storage.GlobalStore.Update(func(tx storage.Tx) error {
for _, memberID := range req.MemberIDs {
if _, ok := tx.GetUser(memberID); !ok {
return ErrMemberNotFound
}
}
chat = NewChat(req)
tx.CreateChat(chat)
return nil
})
chat, err := h.store.CreateChat(c.Context(), req.Title, req.MemberIDs)
if err != nil {
return common.SendAppError(c, err)
}
@@ -43,7 +43,7 @@ func createChat(c fiber.Ctx) error {
return c.Status(fiber.StatusCreated).JSON(chat)
}
func listChats(c fiber.Ctx) error {
func (h *Handler) ListChats(c fiber.Ctx) error {
userID := c.Locals("userID").(uuid.UUID)
limit, err := common.ParseLimit(c, 50)
@@ -55,19 +55,12 @@ func listChats(c fiber.Ctx) error {
if err != nil {
return common.SendAppError(c, err)
}
if cursor != nil && userID != cursor.ContextID {
if cursor != nil && cursor.ContextID != userID {
return common.SendError(c, fiber.StatusBadRequest,
common.ErrorCodeInvalidRequest, "bad cursor value")
}
var page *common.PaginatedResponse[storage.Entity]
err = storage.GlobalStore.View(func(tx storage.ReadOnlyTx) error {
found, fetchErr := tx.GetUserChats(userID, limit, cursor)
page = found
return fetchErr
})
page, err := h.store.ListChats(c.Context(), userID, limit, cursor)
if err != nil {
return common.SendAppError(c, err)
}
@@ -75,29 +68,16 @@ func listChats(c fiber.Ctx) error {
return c.JSON(page)
}
func getChat(c fiber.Ctx) error {
func (h *Handler) GetChat(c fiber.Ctx) error {
userID := c.Locals("userID").(uuid.UUID)
chatID, err := uuid.Parse(c.Params("chat_id"))
if err != nil {
return common.SendAppError(c, ErrInvalidChatID)
return common.SendError(c, fiber.StatusBadRequest,
common.ErrorCodeInvalidRequest, "invalid chat_id format")
}
var chat storage.ChatEntity
err = storage.GlobalStore.View(func(tx storage.ReadOnlyTx) error {
if !tx.IsMember(userID, chatID) {
return ErrChatNotFound
}
found, ok := tx.GetChat(chatID)
if !ok {
return ErrChatNotFound
}
chat = found
return nil
})
chat, err := h.store.GetChatForUser(c.Context(), userID, chatID)
if err != nil {
return common.SendAppError(c, err)
}
-41
View File
@@ -1,41 +0,0 @@
package chats
import (
"time"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"github.com/google/uuid"
)
type Chat struct {
ID uuid.UUID `json:"id"`
Title string `json:"title"`
MemberIDs []uuid.UUID `json:"member_ids"`
CreatedAt common.RFCFormTime `json:"created_at"`
}
type CreateChatRequest struct {
Title string `json:"title" validate:"required"`
MemberIDs []uuid.UUID `json:"member_ids" validate:"required"`
}
func NewChat(req CreateChatRequest) Chat {
return Chat{
ID: uuid.New(),
Title: req.Title,
MemberIDs: req.MemberIDs,
CreatedAt: common.NowUTC(),
}
}
func (c Chat) GetID() uuid.UUID {
return c.ID
}
func (c Chat) GetCreatedAt() time.Time {
return time.Time(c.CreatedAt)
}
func (c Chat) GetMemberIDs() []uuid.UUID {
return c.MemberIDs
}
+9 -5
View File
@@ -1,9 +1,13 @@
package chats
import "github.com/gofiber/fiber/v3"
import (
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
)
func RegisterRoutes(router fiber.Router) {
router.Post("/chats", createChat)
router.Get("/chats", listChats)
router.Get("/chats/:chat_id", getChat)
func RegisterRoutes(router fiber.Router, st *store.Store) {
handler := NewHandler(st)
router.Post("/chats", handler.CreateChat)
router.Get("/chats", handler.ListChats)
router.Get("/chats/:chat_id", handler.GetChat)
}
+22 -1
View File
@@ -4,6 +4,7 @@ import (
"errors"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/requestid"
)
const (
@@ -80,6 +81,16 @@ func Internal() *AppError {
return NewAppError(fiber.StatusInternalServerError, ErrorCodeInternal, "Internal server error")
}
func Unavailable(message string) *AppError {
return NewAppError(fiber.StatusServiceUnavailable, ErrorCodeUnavailable, message)
}
// IsCode reports whether err is an AppError with the given contract code.
func IsCode(err error, code string) bool {
var appErr *AppError
return errors.As(err, &appErr) && appErr.Code == code
}
func ErrorCodeFromStatus(status int) string {
switch status {
case fiber.StatusBadRequest:
@@ -104,7 +115,10 @@ func ErrorCodeFromStatus(status int) string {
}
func getRequestID(c fiber.Ctx) string {
return string(c.Response().Header.Peek("X-Request-Id"))
if id := string(c.Response().Header.Peek("X-Request-Id")); id != "" {
return id
}
return requestid.FromContext(c)
}
func SendError(c fiber.Ctx, status int, code, message string) error {
@@ -120,3 +134,10 @@ func SendAppError(c fiber.Ctx, err error) error {
return SendError(c, fiber.StatusInternalServerError,
ErrorCodeInternal, "Internal server error")
}
// SendChallenge emits a 401 with the WWW-Authenticate value required by the
// contract: Basic for login, Bearer for every protected endpoint.
func SendChallenge(c fiber.Ctx, challenge, message string) error {
c.Set(fiber.HeaderWWWAuthenticate, challenge)
return SendError(c, fiber.StatusUnauthorized, ErrorCodeUnauthorized, message)
}
+45 -135
View File
@@ -2,7 +2,7 @@ package common
import (
"encoding/base64"
"sort"
"strconv"
"strings"
"time"
@@ -10,189 +10,99 @@ import (
"github.com/google/uuid"
)
// CursorKeyCtx is the opaque keyset position: (created_at, id) plus the
// resource/user the cursor belongs to. ContextID stops a cursor from one chat
// or user list being replayed against another.
type CursorKeyCtx struct {
Time time.Time
ID uuid.UUID
ContextID uuid.UUID
}
type cursorKey struct {
time time.Time
id uuid.UUID
}
type CreatedAtIDable interface {
GetCreatedAt() time.Time
GetID() uuid.UUID
}
type PaginatedResponse[T any] struct {
type Page[T any] struct {
Items []T `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func ParseLimit(c fiber.Ctx, defaultLimit int) (int, error) {
limitStr, exists := c.Queries()["limit"]
if limitStr == "" {
if !exists {
return defaultLimit, nil
}
if !exists {
return defaultLimit, nil
}
if strings.TrimSpace(limitStr) == "" {
return 0, BadRequest("limit param declared but empty")
}
limit, ok := validateLimitStr(limitStr)
if !ok {
limit, err := strconv.Atoi(limitStr)
if err != nil || limit < 1 || limit > 100 {
return 0, BadRequest("limit must be an integer between 1 and 100")
}
return limit, nil
}
func ParseCursor(c fiber.Ctx) (*CursorKeyCtx, error) {
cursorStr, exists := c.Queries()["cursor"]
if cursorStr == "" {
if !exists {
return nil, nil
}
if !exists {
return nil, nil
}
if strings.TrimSpace(cursorStr) == "" {
return nil, BadRequest("cursor param declared but empty")
}
cursor := DecodeCursor(cursorStr)
if cursor == nil {
cursor, ok := DecodeCursor(cursorStr)
if !ok {
return nil, BadRequest("invalid cursor format")
}
return cursor, nil
}
func Paginate[T CreatedAtIDable](
items []T,
limit int,
cursor *CursorKeyCtx,
contextID uuid.UUID,
) (*PaginatedResponse[T], error) {
enforceOrder(items)
start := 0
if cursor != nil {
key := cursorKey{time: cursor.Time, id: cursor.ID}
position, found := findAfter(items, key)
if !found {
return nil, BadRequest("cursor invalid")
}
if position == -1 {
position = len(items)
}
start = position
}
end := start + limit
if end > len(items) {
end = len(items)
}
page := items[start:end]
if page == nil {
page = []T{}
}
var nextCursor *string
if end < len(items) {
last := items[end-1]
encoded := encodeCursor(CursorKeyCtx{
Time: last.GetCreatedAt(),
ID: last.GetID(),
ContextID: contextID,
})
nextCursor = &encoded
}
return &PaginatedResponse[T]{
Items: page,
NextCursor: nextCursor,
}, nil
}
func encodeCursor(key CursorKeyCtx) string {
timeStr := key.Time.UTC().Format(time.RFC3339Nano)
raw := timeStr + "|" + key.ID.String() + "|" + key.ContextID.String()
func EncodeCursor(key CursorKeyCtx) string {
raw := key.Time.UTC().Format(time.RFC3339Nano) + "|" + key.ID.String() + "|" + key.ContextID.String()
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
func DecodeCursor(cursor string) *CursorKeyCtx {
func DecodeCursor(cursor string) (*CursorKeyCtx, bool) {
data, err := base64.RawURLEncoding.DecodeString(cursor)
if err != nil {
return nil
return nil, false
}
parts := strings.SplitN(string(data), "|", 3)
if len(parts) != 3 {
return nil
return nil, false
}
parsedTime, err := time.Parse(time.RFC3339Nano, parts[0])
if err != nil {
return nil
return nil, false
}
parsedID, err := uuid.Parse(parts[1])
if err != nil {
return nil
return nil, false
}
parsedContextID, err := uuid.Parse(parts[2])
parsedContext, err := uuid.Parse(parts[2])
if err != nil {
return nil, false
}
return &CursorKeyCtx{Time: parsedTime, ID: parsedID, ContextID: parsedContext}, true
}
// NextCursor returns a cursor pointing at the last item of a page when more
// rows exist. limit+1 rows are fetched by the store, so a non-nil cursor means
// the next page is known to be non-empty at read time.
func NextCursor[T interface {
GetID() uuid.UUID
GetCreatedAt() time.Time
}](items []T, hasMore bool, contextID uuid.UUID) *string {
if !hasMore || len(items) == 0 {
return nil
}
return &CursorKeyCtx{
Time: parsedTime,
ID: parsedID,
ContextID: parsedContextID,
}
}
func findAfter[T CreatedAtIDable](items []T, key cursorKey) (position int, keyFound bool) {
for i, item := range items {
itemKey := keyOf(item)
if itemKey == key {
keyFound = true
}
if after(itemKey, key) {
return i, true
}
}
return -1, keyFound
}
func keyOf(item CreatedAtIDable) cursorKey {
return cursorKey{
time: item.GetCreatedAt(),
id: item.GetID(),
}
}
func after(a, b cursorKey) bool {
if !a.time.Equal(b.time) {
return a.time.After(b.time)
}
return a.id.String() > b.id.String()
}
func enforceOrder[T CreatedAtIDable](items []T) {
sort.Slice(items, func(i, j int) bool {
return after(keyOf(items[j]), keyOf(items[i]))
last := items[len(items)-1]
encoded := EncodeCursor(CursorKeyCtx{
Time: last.GetCreatedAt(),
ID: last.GetID(),
ContextID: contextID,
})
return &encoded
}
+49
View File
@@ -0,0 +1,49 @@
package common
import (
"testing"
"time"
"github.com/google/uuid"
)
func TestCursorRoundTrip(t *testing.T) {
want := CursorKeyCtx{
Time: time.Date(2026, 10, 20, 12, 30, 45, 123456789, time.UTC),
ID: uuid.MustParse("11111111-1111-4111-8111-111111111111"),
ContextID: uuid.MustParse("22222222-2222-4222-8222-222222222222"),
}
encoded := EncodeCursor(want)
got, ok := DecodeCursor(encoded)
if !ok {
t.Fatal("cursor did not decode")
}
if !got.Time.Equal(want.Time) || got.ID != want.ID || got.ContextID != want.ContextID {
t.Fatalf("cursor round trip changed the key: %+v", got)
}
for _, invalid := range []string{"not-base64!", "", "aGVsbG8"} {
if _, ok := DecodeCursor(invalid); ok {
t.Fatalf("invalid cursor %q was accepted", invalid)
}
}
}
func TestValidatePasswordRange(t *testing.T) {
cases := []struct {
password string
valid bool
}{
{"short", false},
{"12345678901", false},
{"123456789012", true},
{"пароль-из-двенадцати", true},
{"😀", false},
}
for _, tc := range cases {
if got := ValidatePassword(tc.password) == ""; got != tc.valid {
t.Fatalf("ValidatePassword(%q) valid=%v, want %v", tc.password, got, tc.valid)
}
}
}
+13 -2
View File
@@ -34,7 +34,7 @@ func BindJSON(c fiber.Ctx, req any) error {
decoder.DisallowUnknownFields()
if err := decoder.Decode(req); err != nil {
return BadRequest(err.Error())
return BadRequest("invalid JSON body")
}
var extra json.RawMessage
@@ -43,7 +43,7 @@ func BindJSON(c fiber.Ctx, req any) error {
}
if err := validate.Struct(req); err != nil {
return BadRequest("field validation failed: " + err.Error())
return BadRequest("field validation failed")
}
return nil
@@ -74,6 +74,17 @@ func ValidateCreateUser(username, displayName string) string {
return ""
}
// ValidatePassword enforces the contract range in Unicode code points. The
// upper bound matters: bcrypt would silently truncate, which is why this
// project uses Argon2id instead.
func ValidatePassword(password string) string {
if !strLenBetween(password, 12, 128) {
return "password must be between 12 and 128 Unicode code points"
}
return ""
}
func ValidateChatTitle(title string) string {
if blank(title) {
return "title must not be empty or only whitespace"
+107
View File
@@ -0,0 +1,107 @@
// AGENT: All runtime configuration is read here so every other package receives
// explicit values instead of calling os.Getenv. Values are compatible with
// .env.example and support the *_FILE convention used by Compose secrets.
package config
import (
"fmt"
"os"
"strconv"
"strings"
"time"
)
type Config struct {
Host string
Port string
SessionTTL time.Duration
DatabaseURL string
CacheURL string
DBMaxConns int32
DBTimeout time.Duration
RedisTimeout time.Duration
StartupWait time.Duration
}
func Load() (Config, error) {
cfg := Config{
Host: envOr("APP_HOST", "0.0.0.0"),
Port: envOr("APP_PORT", "8080"),
DBMaxConns: 10,
DBTimeout: 5 * time.Second,
RedisTimeout: 2 * time.Second,
StartupWait: 30 * time.Second,
}
ttlSeconds, err := strconv.Atoi(envOr("SESSION_TTL_SECONDS", "3600"))
if err != nil || ttlSeconds < 1 {
return cfg, fmt.Errorf("SESSION_TTL_SECONDS must be a positive integer")
}
cfg.SessionTTL = time.Duration(ttlSeconds) * time.Second
if value := envOr("DB_POOL_MAX_CONNS", ""); value != "" {
n, convErr := strconv.Atoi(value)
if convErr != nil || n < 1 || n > 100 {
return cfg, fmt.Errorf("DB_POOL_MAX_CONNS must be an integer between 1 and 100")
}
cfg.DBMaxConns = int32(n)
}
cfg.DatabaseURL, err = secret("DATABASE_URL")
if err != nil {
return cfg, err
}
if cfg.DatabaseURL == "" {
return cfg, fmt.Errorf("DATABASE_URL or DATABASE_URL_FILE is required")
}
cfg.CacheURL, err = secret("CACHE_URL")
if err != nil {
return cfg, err
}
if cfg.CacheURL == "" {
cfg.CacheURL, err = secret("REDIS_URL")
if err != nil {
return cfg, err
}
}
if cfg.CacheURL == "" {
return cfg, fmt.Errorf("CACHE_URL or CACHE_URL_FILE is required")
}
if value := strings.ToLower(envOr("SESSION_STORE", "redis")); value != "redis" {
return cfg, fmt.Errorf("SESSION_STORE must be redis (got %q)", value)
}
return cfg, nil
}
func envOr(name, fallback string) string {
if value := os.Getenv(name); value != "" {
return value
}
return fallback
}
func secret(name string) (string, error) {
if value := os.Getenv(name); value != "" {
return value, nil
}
path := os.Getenv(name + "_FILE")
if path == "" {
return "", nil
}
data, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("read %s_FILE: %w", name, err)
}
value := strings.TrimSpace(string(data))
if value == "" {
return "", fmt.Errorf("%s_FILE is empty", name)
}
return value, nil
}
+127
View File
@@ -0,0 +1,127 @@
// AGENT: A tiny migration runner instead of a framework: one advisory lock,
// one schema_migrations row per file, each file in its own transaction.
package database
import (
"context"
"embed"
"fmt"
"io/fs"
"sort"
"time"
"github.com/jackc/pgx/v5/pgxpool"
)
//go:embed migrations/*.sql
var migrationFiles embed.FS
const migrationLockID int64 = 728_2026
func Connect(ctx context.Context, url string, maxConns int32, wait time.Duration) (*pgxpool.Pool, error) {
cfg, err := pgxpool.ParseConfig(url)
if err != nil {
return nil, fmt.Errorf("parse DATABASE_URL: %w", err)
}
cfg.MaxConns = maxConns
cfg.MinConns = 1
cfg.MaxConnLifetime = 30 * time.Minute
cfg.MaxConnIdleTime = 5 * time.Minute
cfg.HealthCheckPeriod = 30 * time.Second
cfg.ConnConfig.ConnectTimeout = 3 * time.Second
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, fmt.Errorf("create pool: %w", err)
}
// AGENT: Compose may start the API while PostgreSQL is still booting. A bounded
// retry keeps the container from crash-looping without hiding a permanent error.
deadline := time.Now().Add(wait)
for {
pingCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
err = pool.Ping(pingCtx)
cancel()
if err == nil {
return pool, nil
}
if time.Now().After(deadline) || ctx.Err() != nil {
pool.Close()
return nil, fmt.Errorf("postgres is not reachable: %w", err)
}
time.Sleep(500 * time.Millisecond)
}
}
func Migrate(ctx context.Context, pool *pgxpool.Pool) error {
conn, err := pool.Acquire(ctx)
if err != nil {
return fmt.Errorf("acquire migration connection: %w", err)
}
defer conn.Release()
if _, err = conn.Exec(ctx, "SELECT pg_advisory_lock($1)", migrationLockID); err != nil {
return fmt.Errorf("acquire migration lock: %w", err)
}
defer func() {
unlockCtx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
_, _ = conn.Exec(unlockCtx, "SELECT pg_advisory_unlock($1)", migrationLockID)
}()
if _, err = conn.Exec(ctx, `
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT now()
)`); err != nil {
return fmt.Errorf("create schema_migrations: %w", err)
}
entries, err := fs.ReadDir(migrationFiles, "migrations")
if err != nil {
return fmt.Errorf("read embedded migrations: %w", err)
}
sort.Slice(entries, func(i, j int) bool { return entries[i].Name() < entries[j].Name() })
for _, entry := range entries {
if entry.IsDir() {
continue
}
var applied bool
if err = conn.QueryRow(ctx,
"SELECT EXISTS(SELECT 1 FROM schema_migrations WHERE version = $1)", entry.Name(),
).Scan(&applied); err != nil {
return fmt.Errorf("check migration %s: %w", entry.Name(), err)
}
if applied {
continue
}
body, readErr := migrationFiles.ReadFile("migrations/" + entry.Name())
if readErr != nil {
return fmt.Errorf("read migration %s: %w", entry.Name(), readErr)
}
tx, beginErr := conn.Begin(ctx)
if beginErr != nil {
return fmt.Errorf("begin migration %s: %w", entry.Name(), beginErr)
}
if _, execErr := tx.Exec(ctx, string(body)); execErr != nil {
_ = tx.Rollback(ctx)
return fmt.Errorf("apply migration %s: %w", entry.Name(), execErr)
}
if _, insertErr := tx.Exec(ctx,
"INSERT INTO schema_migrations (version) VALUES ($1)", entry.Name(),
); insertErr != nil {
_ = tx.Rollback(ctx)
return fmt.Errorf("record migration %s: %w", entry.Name(), insertErr)
}
if commitErr := tx.Commit(ctx); commitErr != nil {
return fmt.Errorf("commit migration %s: %w", entry.Name(), commitErr)
}
}
return nil
}
@@ -0,0 +1,46 @@
-- AGENT: Single versioned baseline migration for lab 2. The application records
-- applied versions in schema_migrations, so rerunning it never duplicates rows.
-- The unique username constraint is the authoritative defence against the
-- concurrent-registration race, not a SELECT followed by an INSERT.
CREATE TABLE IF NOT EXISTS users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL,
CONSTRAINT users_username_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 IF NOT EXISTS chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL,
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS chat_members_user_idx
ON chat_members (user_id, chat_id);
CREATE TABLE IF NOT EXISTS messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
text text NOT NULL,
created_at timestamptz NOT NULL,
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
);
-- AGENT: This composite index matches the only history predicate and sort order:
-- (chat_id, created_at, id). It lets each keyset page seek directly to the cursor
-- instead of scanning the chat history from the beginning.
CREATE INDEX IF NOT EXISTS messages_chat_created_id_idx
ON messages (chat_id, created_at, id);
+35 -7
View File
@@ -3,25 +3,53 @@ package health
import (
"sync/atomic"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/session"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
)
type Handler struct {
store *store.Store
sessions *session.Store
}
func NewHandler(st *store.Store, sessions *session.Store) *Handler {
return &Handler{store: st, sessions: sessions}
}
var shuttingDown atomic.Bool
func SignalShutdown() {
shuttingDown.Store(true)
}
func live(c fiber.Ctx) error {
return c.JSON(fiber.Map{"status": "ok"})
type Status struct {
Status string `json:"status"`
}
func ready(c fiber.Ctx) error {
func (h *Handler) Live(c fiber.Ctx) error {
return c.JSON(Status{Status: "ok"})
}
// Ready answers whether the synchronous mandatory path can be served. Both
// PostgreSQL and Redis are critical here: business data and sessions live in
// them respectively.
func (h *Handler) Ready(c fiber.Ctx) error {
if shuttingDown.Load() {
return common.SendError(c, fiber.StatusInternalServerError,
common.ErrorCodeInternal, "app currently shutting down")
return common.SendError(c, fiber.StatusServiceUnavailable,
common.ErrorCodeUnavailable, "service is shutting down")
}
return c.JSON(fiber.Map{"status": "ok"})
if err := h.store.Ping(c.Context()); err != nil {
return common.SendError(c, fiber.StatusServiceUnavailable,
common.ErrorCodeUnavailable, "database unavailable")
}
if err := h.sessions.Ping(c.Context()); err != nil {
return common.SendError(c, fiber.StatusServiceUnavailable,
common.ErrorCodeUnavailable, "session store unavailable")
}
return c.JSON(Status{Status: "ok"})
}
+9 -4
View File
@@ -1,8 +1,13 @@
package health
import "github.com/gofiber/fiber/v3"
import (
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/session"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
)
func RegisterRoutes(router fiber.Router) {
router.Get("/live", live)
router.Get("/ready", ready)
func RegisterRoutes(router fiber.Router, st *store.Store, sessions *session.Store) {
handler := NewHandler(st, sessions)
router.Get("/live", handler.Live)
router.Get("/ready", handler.Ready)
}
-8
View File
@@ -1,8 +0,0 @@
package messages
import "gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
var (
ErrChatNotFound = common.NotFound("chat not found")
ErrInvalidChatID = common.BadRequest("invalid chat_id format")
)
+22 -34
View File
@@ -1,40 +1,42 @@
package messages
import (
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/storage"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
"github.com/google/uuid"
)
func createMessage(c fiber.Ctx) error {
type Handler struct {
store *store.Store
}
func NewHandler(st *store.Store) *Handler {
return &Handler{store: st}
}
type CreateMessageRequest struct {
Text string `json:"text" validate:"required"`
}
func (h *Handler) CreateMessage(c fiber.Ctx) error {
userID := c.Locals("userID").(uuid.UUID)
chatID, err := uuid.Parse(c.Params("chat_id"))
if err != nil {
return common.SendAppError(c, ErrInvalidChatID)
return common.SendError(c, fiber.StatusBadRequest,
common.ErrorCodeInvalidRequest, "invalid chat_id format")
}
var req CreateMessageRequest
if err := common.BindJSON(c, &req); err != nil {
return common.SendAppError(c, err)
}
if msg := common.ValidateMessageText(req.Text); msg != "" {
return common.SendError(c, fiber.StatusBadRequest, common.ErrorCodeInvalidRequest, msg)
}
var message Message
err = storage.GlobalStore.Update(func(tx storage.Tx) error {
if !tx.IsMember(userID, chatID) {
return ErrChatNotFound
}
message = NewMessage(chatID, userID, req.Text)
tx.CreateMessage(message)
return nil
})
message, err := h.store.CreateMessage(c.Context(), chatID, userID, req.Text)
if err != nil {
return common.SendAppError(c, err)
}
@@ -42,12 +44,13 @@ func createMessage(c fiber.Ctx) error {
return c.Status(fiber.StatusCreated).JSON(message)
}
func listMessages(c fiber.Ctx) error {
func (h *Handler) ListMessages(c fiber.Ctx) error {
userID := c.Locals("userID").(uuid.UUID)
chatID, err := uuid.Parse(c.Params("chat_id"))
if err != nil {
return common.SendAppError(c, ErrInvalidChatID)
return common.SendError(c, fiber.StatusBadRequest,
common.ErrorCodeInvalidRequest, "invalid chat_id format")
}
limit, err := common.ParseLimit(c, 50)
@@ -60,22 +63,7 @@ func listMessages(c fiber.Ctx) error {
return common.SendAppError(c, err)
}
if cursor != nil && chatID != cursor.ContextID {
return common.SendError(c, fiber.StatusBadRequest,
common.ErrorCodeInvalidRequest, "bad cursor value")
}
var page *common.PaginatedResponse[storage.Entity]
err = storage.GlobalStore.View(func(tx storage.ReadOnlyTx) error {
if !tx.IsMember(userID, chatID) {
return ErrChatNotFound
}
found, fetchErr := tx.GetChatMessages(chatID, limit, cursor)
page = found
return fetchErr
})
page, err := h.store.ListMessages(c.Context(), userID, chatID, limit, cursor)
if err != nil {
return common.SendAppError(c, err)
}
-42
View File
@@ -1,42 +0,0 @@
package messages
import (
"time"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"github.com/google/uuid"
)
type Message struct {
ID uuid.UUID `json:"id"`
ChatID uuid.UUID `json:"chat_id"`
SenderID uuid.UUID `json:"sender_id"`
Text string `json:"text"`
CreatedAt common.RFCFormTime `json:"created_at"`
}
type CreateMessageRequest struct {
Text string `json:"text" validate:"required"`
}
func NewMessage(chatID, senderID uuid.UUID, text string) Message {
return Message{
ID: uuid.New(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: common.NowUTC(),
}
}
func (m Message) GetID() uuid.UUID {
return m.ID
}
func (m Message) GetCreatedAt() time.Time {
return time.Time(m.CreatedAt)
}
func (m Message) GetChatID() uuid.UUID {
return m.ChatID
}
+8 -4
View File
@@ -1,8 +1,12 @@
package messages
import "github.com/gofiber/fiber/v3"
import (
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
)
func RegisterRoutes(router fiber.Router) {
router.Post("/chats/:chat_id/messages", createMessage)
router.Get("/chats/:chat_id/messages", listMessages)
func RegisterRoutes(router fiber.Router, st *store.Store) {
handler := NewHandler(st)
router.Post("/chats/:chat_id/messages", handler.CreateMessage)
router.Get("/chats/:chat_id/messages", handler.ListMessages)
}
+47
View File
@@ -0,0 +1,47 @@
package model
import (
"time"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common"
"github.com/google/uuid"
)
type User struct {
ID uuid.UUID `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
PasswordHash string `json:"-"`
CreatedAt common.RFCFormTime `json:"created_at"`
}
func (u User) GetID() uuid.UUID { return u.ID }
func (u User) GetCreatedAt() time.Time { return time.Time(u.CreatedAt) }
type Chat struct {
ID uuid.UUID `json:"id"`
Title string `json:"title"`
MemberIDs []uuid.UUID `json:"member_ids"`
CreatedAt common.RFCFormTime `json:"created_at"`
}
func (c Chat) GetID() uuid.UUID { return c.ID }
func (c Chat) GetCreatedAt() time.Time { return time.Time(c.CreatedAt) }
type Message struct {
ID uuid.UUID `json:"id"`
ChatID uuid.UUID `json:"chat_id"`
SenderID uuid.UUID `json:"sender_id"`
Text string `json:"text"`
CreatedAt common.RFCFormTime `json:"created_at"`
}
func (m Message) GetID() uuid.UUID { return m.ID }
func (m Message) GetCreatedAt() time.Time { return time.Time(m.CreatedAt) }
type Session struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt common.RFCFormTime `json:"expires_at"`
User User `json:"user"`
}
+106
View File
@@ -0,0 +1,106 @@
// AGENT: Redis is the single session store for lab 2 grade 4. PostgreSQL stays
// the source of truth for business data. The token itself is never stored: Redis
// holds SHA-256(token) -> user id with a TTL, so a leaked Redis dump does not
// hand out usable bearer tokens.
package session
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"errors"
"fmt"
"strings"
"time"
"github.com/google/uuid"
"github.com/redis/go-redis/v9"
)
var ErrNotFound = errors.New("session not found")
const keyPrefix = "messenger:session:"
type Store struct {
client *redis.Client
ttl time.Duration
timeout time.Duration
}
func New(rawURL string, ttl, timeout time.Duration) (*Store, error) {
options, err := redis.ParseURL(rawURL)
if err != nil {
return nil, fmt.Errorf("parse CACHE_URL: %w", err)
}
options.PoolSize = 10
options.DialTimeout = timeout
options.ReadTimeout = timeout
options.WriteTimeout = timeout
options.MaxRetries = 0
return &Store{
client: redis.NewClient(options),
ttl: ttl,
timeout: timeout,
}, nil
}
func (s *Store) Close() error {
return s.client.Close()
}
func (s *Store) Ping(ctx context.Context) error {
pingCtx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
return s.client.Ping(pingCtx).Err()
}
// Create returns the raw token exactly once and stores only its digest.
func (s *Store) Create(ctx context.Context, userID uuid.UUID) (string, time.Time, error) {
raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
return "", time.Time{}, fmt.Errorf("generate token: %w", err)
}
token := base64.RawURLEncoding.EncodeToString(raw)
expiresAt := time.Now().UTC().Truncate(time.Second).Add(s.ttl)
opCtx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
if err := s.client.Set(opCtx, keyFor(token), userID.String(), s.ttl).Err(); err != nil {
return "", time.Time{}, err
}
return token, expiresAt, nil
}
func (s *Store) Lookup(ctx context.Context, token string) (uuid.UUID, error) {
opCtx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
value, err := s.client.Get(opCtx, keyFor(token)).Result()
if errors.Is(err, redis.Nil) {
return uuid.Nil, ErrNotFound
}
if err != nil {
return uuid.Nil, err
}
userID, err := uuid.Parse(value)
if err != nil {
return uuid.Nil, ErrNotFound
}
return userID, nil
}
func (s *Store) Revoke(ctx context.Context, token string) error {
opCtx, cancel := context.WithTimeout(ctx, s.timeout)
defer cancel()
return s.client.Del(opCtx, keyFor(token)).Err()
}
func keyFor(token string) string {
sum := sha256.Sum256([]byte(strings.TrimSpace(token)))
return keyPrefix + hex.EncodeToString(sum[:])
}
-145
View File
@@ -1,145 +0,0 @@
package storage
import (
"slices"
"sync"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"github.com/google/uuid"
)
type Entity = common.CreatedAtIDable
type UserEntity interface {
Entity
GetUsername() string
}
type ChatEntity interface {
Entity
GetMemberIDs() []uuid.UUID
}
type MessageEntity interface {
Entity
GetChatID() uuid.UUID
}
type Store struct {
mu sync.RWMutex
users map[uuid.UUID]UserEntity
usernames map[string]uuid.UUID
chats map[uuid.UUID]ChatEntity
userChats map[uuid.UUID][]uuid.UUID
chatMessages map[uuid.UUID][]MessageEntity
}
func NewStore() *Store {
return &Store{
users: make(map[uuid.UUID]UserEntity),
usernames: make(map[string]uuid.UUID),
chats: make(map[uuid.UUID]ChatEntity),
userChats: make(map[uuid.UUID][]uuid.UUID),
chatMessages: make(map[uuid.UUID][]MessageEntity),
}
}
var GlobalStore = NewStore()
type ReadOnlyTx interface {
GetUser(id uuid.UUID) (UserEntity, bool)
GetChat(id uuid.UUID) (ChatEntity, bool)
UsernameExists(username string) bool
IsMember(userID, chatID uuid.UUID) bool
GetChatMessages(chatID uuid.UUID, limit int, cursor *common.CursorKeyCtx) (*common.PaginatedResponse[Entity], error)
GetUserChats(userID uuid.UUID, limit int, cursor *common.CursorKeyCtx) (*common.PaginatedResponse[Entity], error)
}
type Tx interface {
ReadOnlyTx
CreateUser(user UserEntity)
CreateChat(chat ChatEntity)
CreateMessage(msg MessageEntity)
}
func (s *Store) View(apply func(tx ReadOnlyTx) error) error {
s.mu.RLock()
defer s.mu.RUnlock()
return apply(s)
}
func (s *Store) Update(apply func(tx Tx) error) error {
s.mu.Lock()
defer s.mu.Unlock()
return apply(s)
}
func (s *Store) CreateUser(user UserEntity) {
s.users[user.GetID()] = user
s.usernames[user.GetUsername()] = user.GetID()
s.userChats[user.GetID()] = []uuid.UUID{}
}
func (s *Store) UsernameExists(username string) bool {
_, exists := s.usernames[username]
return exists
}
func (s *Store) GetUser(id uuid.UUID) (UserEntity, bool) {
user, ok := s.users[id]
return user, ok
}
func (s *Store) CreateChat(chat ChatEntity) {
s.chats[chat.GetID()] = chat
for _, memberID := range chat.GetMemberIDs() {
s.userChats[memberID] = append(s.userChats[memberID], chat.GetID())
}
s.chatMessages[chat.GetID()] = []MessageEntity{}
}
func (s *Store) GetChat(id uuid.UUID) (ChatEntity, bool) {
chat, ok := s.chats[id]
return chat, ok
}
func (s *Store) IsMember(userID, chatID uuid.UUID) bool {
chat, ok := s.chats[chatID]
if !ok {
return false
}
return slices.Contains(chat.GetMemberIDs(), userID)
}
func (s *Store) CreateMessage(msg MessageEntity) {
s.chatMessages[msg.GetChatID()] = append(s.chatMessages[msg.GetChatID()], msg)
}
func (s *Store) GetUserChats(userID uuid.UUID, limit int, cursor *common.CursorKeyCtx) (*common.PaginatedResponse[Entity], error) {
chatIDs := s.userChats[userID]
userChats := make([]Entity, 0, len(chatIDs))
for _, chatID := range chatIDs {
if chat, exists := s.chats[chatID]; exists {
userChats = append(userChats, chat)
}
}
return common.Paginate(userChats, limit, cursor, userID)
}
func (s *Store) GetChatMessages(chatID uuid.UUID, limit int, cursor *common.CursorKeyCtx) (*common.PaginatedResponse[Entity], error) {
chatMessages := s.chatMessages[chatID]
messages := make([]Entity, 0, len(chatMessages))
for _, message := range chatMessages {
messages = append(messages, message)
}
return common.Paginate(messages, limit, cursor, chatID)
}
+357
View File
@@ -0,0 +1,357 @@
// AGENT: Concrete PostgreSQL store: plain parameterized SQL, one bounded pool,
// explicit transaction boundaries. It returns contract AppErrors so HTTP status
// mapping stays in one place.
package store
import (
"context"
"errors"
"time"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/model"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
)
type Store struct {
pool *pgxpool.Pool
timeout time.Duration
}
func New(pool *pgxpool.Pool, timeout time.Duration) *Store {
return &Store{pool: pool, timeout: timeout}
}
func (s *Store) withTimeout(ctx context.Context) (context.Context, context.CancelFunc) {
return context.WithTimeout(ctx, s.timeout)
}
func (s *Store) Ping(ctx context.Context) error {
pingCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
return s.pool.Ping(pingCtx)
}
func (s *Store) CreateUser(ctx context.Context, username, displayName, passwordHash string) (model.User, error) {
ctx, cancel := s.withTimeout(ctx)
defer cancel()
user := model.User{
ID: uuid.New(),
Username: username,
DisplayName: displayName,
PasswordHash: passwordHash,
CreatedAt: common.NowUTC(),
}
_, err := s.pool.Exec(ctx, `
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)`,
user.ID, user.Username, user.DisplayName, user.PasswordHash, time.Time(user.CreatedAt))
if err != nil {
// AGENT: The unique index is the real guard. Two concurrent registrations
// with the same username both reach INSERT; exactly one commits, the other
// gets SQLSTATE 23505 and is mapped to 409 instead of a 500.
if isUniqueViolation(err) {
return model.User{}, common.Conflict("username already taken")
}
return model.User{}, dbError(err)
}
return user, nil
}
func (s *Store) GetUserByID(ctx context.Context, id uuid.UUID) (model.User, error) {
ctx, cancel := s.withTimeout(ctx)
defer cancel()
return s.scanUser(s.pool.QueryRow(ctx, `
SELECT id, username, display_name, password_hash, created_at
FROM users WHERE id = $1`, id))
}
func (s *Store) GetUserByUsername(ctx context.Context, username string) (model.User, error) {
ctx, cancel := s.withTimeout(ctx)
defer cancel()
return s.scanUser(s.pool.QueryRow(ctx, `
SELECT id, username, display_name, password_hash, created_at
FROM users WHERE username = $1`, username))
}
type rowScanner interface {
Scan(dest ...any) error
}
func (s *Store) scanUser(row rowScanner) (model.User, error) {
var user model.User
var createdAt time.Time
if err := row.Scan(&user.ID, &user.Username, &user.DisplayName, &user.PasswordHash, &createdAt); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return model.User{}, common.NotFound("user not found")
}
return model.User{}, dbError(err)
}
user.CreatedAt = common.RFCFormTime(createdAt.UTC())
return user, nil
}
// CreateChat inserts the chat and every membership row in one transaction.
// Any unknown member aborts the whole transaction, so a partially created chat
// can never be observed.
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []uuid.UUID) (model.Chat, error) {
ctx, cancel := s.withTimeout(ctx)
defer cancel()
tx, err := s.pool.Begin(ctx)
if err != nil {
return model.Chat{}, dbError(err)
}
defer func() { _ = tx.Rollback(context.Background()) }()
for _, memberID := range memberIDs {
var exists int
err = tx.QueryRow(ctx, `SELECT 1 FROM users WHERE id = $1`, memberID).Scan(&exists)
if errors.Is(err, pgx.ErrNoRows) {
return model.Chat{}, common.BadRequest("member_id refers to non-existent user")
}
if err != nil {
return model.Chat{}, dbError(err)
}
}
chat := model.Chat{
ID: uuid.New(),
Title: title,
MemberIDs: append([]uuid.UUID(nil), memberIDs...),
CreatedAt: common.NowUTC(),
}
if _, err = tx.Exec(ctx,
`INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`,
chat.ID, chat.Title, time.Time(chat.CreatedAt)); err != nil {
return model.Chat{}, dbError(err)
}
for _, memberID := range memberIDs {
if _, err = tx.Exec(ctx,
`INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)`,
chat.ID, memberID); err != nil {
return model.Chat{}, dbError(err)
}
}
if err = tx.Commit(ctx); err != nil {
return model.Chat{}, dbError(err)
}
return chat, nil
}
func (s *Store) GetChatForUser(ctx context.Context, userID, chatID uuid.UUID) (model.Chat, error) {
ctx, cancel := s.withTimeout(ctx)
defer cancel()
var chat model.Chat
var createdAt time.Time
err := s.pool.QueryRow(ctx, `
SELECT c.id, c.title, c.created_at,
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY user_id)
FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $2
WHERE c.id = $1`, chatID, userID).
Scan(&chat.ID, &chat.Title, &createdAt, &chat.MemberIDs)
if errors.Is(err, pgx.ErrNoRows) {
return model.Chat{}, common.NotFound("chat not found")
}
if err != nil {
return model.Chat{}, dbError(err)
}
chat.CreatedAt = common.RFCFormTime(createdAt.UTC())
return chat, nil
}
func (s *Store) ListChats(ctx context.Context, userID uuid.UUID, limit int, cursor *common.CursorKeyCtx) (*common.Page[model.Chat], error) {
ctx, cancel := s.withTimeout(ctx)
defer cancel()
cursorTime, cursorID := cursorValues(cursor)
rows, err := s.pool.Query(ctx, `
SELECT c.id, c.title, c.created_at,
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY user_id)
FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $1
WHERE (c.created_at, c.id) > ($2, $3)
ORDER BY c.created_at, c.id
LIMIT $4`, userID, cursorTime, cursorID, limit+1)
if err != nil {
return nil, dbError(err)
}
defer rows.Close()
chats := make([]model.Chat, 0, limit)
for rows.Next() {
var chat model.Chat
var createdAt time.Time
if err = rows.Scan(&chat.ID, &chat.Title, &createdAt, &chat.MemberIDs); err != nil {
return nil, dbError(err)
}
chat.CreatedAt = common.RFCFormTime(createdAt.UTC())
chats = append(chats, chat)
}
if err = rows.Err(); err != nil {
return nil, dbError(err)
}
hasMore := len(chats) > limit
if hasMore {
chats = chats[:limit]
}
return &common.Page[model.Chat]{Items: chats, NextCursor: common.NextCursor(chats, hasMore, userID)}, nil
}
func (s *Store) IsMember(ctx context.Context, userID, chatID uuid.UUID) (bool, error) {
ctx, cancel := s.withTimeout(ctx)
defer cancel()
var exists int
err := s.pool.QueryRow(ctx,
`SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`,
chatID, userID).Scan(&exists)
if errors.Is(err, pgx.ErrNoRows) {
return false, nil
}
if err != nil {
return false, dbError(err)
}
return true, nil
}
// CreateMessage uses INSERT ... SELECT so the membership check and the insert
// are a single atomic statement: no window where the user is removed between
// check and write. Zero affected rows means the chat is missing or foreign.
func (s *Store) CreateMessage(ctx context.Context, chatID, senderID uuid.UUID, text string) (model.Message, error) {
ctx, cancel := s.withTimeout(ctx)
defer cancel()
message := model.Message{
ID: uuid.New(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: common.NowUTC(),
}
tag, err := s.pool.Exec(ctx, `
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT $1, $2, $3, $4, $5
WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3)`,
message.ID, message.ChatID, message.SenderID, message.Text, time.Time(message.CreatedAt))
if err != nil {
return model.Message{}, dbError(err)
}
if tag.RowsAffected() == 0 {
return model.Message{}, common.NotFound("chat not found")
}
return message, nil
}
func (s *Store) ListMessages(ctx context.Context, userID, chatID uuid.UUID, limit int, cursor *common.CursorKeyCtx) (*common.Page[model.Message], error) {
isMember, err := s.IsMember(ctx, userID, chatID)
if err != nil {
return nil, err
}
if !isMember {
return nil, common.NotFound("chat not found")
}
// AGENT: Cursor context is checked only after membership, so a foreign
// caller gets 404 and cannot probe cursor validity against someone else's chat.
if cursor != nil && cursor.ContextID != chatID {
return nil, common.BadRequest("bad cursor value")
}
ctx, cancel := s.withTimeout(ctx)
defer cancel()
// AGENT: limit+1 is fetched so next_cursor is known to be non-null without a
// second COUNT query; the extra row is never returned to the client.
cursorTime, cursorID := cursorValues(cursor)
rows, err := s.pool.Query(ctx, `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT $4`, chatID, cursorTime, cursorID, limit+1)
if err != nil {
return nil, dbError(err)
}
defer rows.Close()
messages := make([]model.Message, 0, limit)
for rows.Next() {
var message model.Message
var createdAt time.Time
if err = rows.Scan(&message.ID, &message.ChatID, &message.SenderID, &message.Text, &createdAt); err != nil {
return nil, dbError(err)
}
message.CreatedAt = common.RFCFormTime(createdAt.UTC())
messages = append(messages, message)
}
if err = rows.Err(); err != nil {
return nil, dbError(err)
}
hasMore := len(messages) > limit
if hasMore {
messages = messages[:limit]
}
return &common.Page[model.Message]{
Items: messages,
NextCursor: common.NextCursor(messages, hasMore, chatID),
}, nil
}
func cursorValues(cursor *common.CursorKeyCtx) (time.Time, uuid.UUID) {
if cursor == nil {
return time.Time{}, uuid.Nil
}
return cursor.Time, cursor.ID
}
func isUniqueViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23505"
}
// dbError separates a drained dependency (503) from a real bug (500). SQL
// details never reach the client; callers only emit the AppError message.
func dbError(err error) error {
if err == nil {
return nil
}
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
switch pgErr.Code {
case "23505":
return common.Conflict("resource already exists")
case "23503", "23514", "22P02":
return common.BadRequest("request conflicts with stored data")
}
}
if errors.Is(err, context.DeadlineExceeded) ||
errors.Is(err, context.Canceled) ||
pgconn.SafeToRetry(err) ||
errors.Is(err, pgx.ErrTxClosed) {
return common.Unavailable("database unavailable")
}
return common.Internal()
}
+33 -26
View File
@@ -1,13 +1,28 @@
package users
import (
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/storage"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/auth"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common"
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
"github.com/google/uuid"
)
func createUser(c fiber.Ctx) error {
type Handler struct {
store *store.Store
}
func NewHandler(st *store.Store) *Handler {
return &Handler{store: st}
}
type CreateUserRequest struct {
Username string `json:"username" validate:"required"`
DisplayName string `json:"display_name" validate:"required"`
Password string `json:"password" validate:"required"`
}
func (h *Handler) CreateUser(c fiber.Ctx) error {
var req CreateUserRequest
if err := common.BindJSON(c, &req); err != nil {
return common.SendAppError(c, err)
@@ -16,18 +31,17 @@ func createUser(c fiber.Ctx) error {
if msg := common.ValidateCreateUser(req.Username, req.DisplayName); msg != "" {
return common.SendError(c, fiber.StatusBadRequest, common.ErrorCodeInvalidRequest, msg)
}
if msg := common.ValidatePassword(req.Password); msg != "" {
return common.SendError(c, fiber.StatusBadRequest, common.ErrorCodeInvalidRequest, msg)
}
var user User
hash, err := auth.HashPassword(req.Password)
if err != nil {
return common.SendError(c, fiber.StatusInternalServerError,
common.ErrorCodeInternal, "Internal server error")
}
err := storage.GlobalStore.Update(func(tx storage.Tx) error {
if tx.UsernameExists(req.Username) {
return common.Conflict("username already taken")
}
user = NewUser(req)
tx.CreateUser(user)
return nil
})
user, err := h.store.CreateUser(c.Context(), req.Username, req.DisplayName, hash)
if err != nil {
return common.SendAppError(c, err)
}
@@ -35,20 +49,13 @@ func createUser(c fiber.Ctx) error {
return c.Status(fiber.StatusCreated).JSON(user)
}
func getCurrentUser(c fiber.Ctx) error {
userID := c.Locals("userID").(uuid.UUID)
func (h *Handler) GetCurrentUser(c fiber.Ctx) error {
userID, ok := c.Locals("userID").(uuid.UUID)
if !ok {
return common.SendChallenge(c, `Bearer realm="messenger"`, "authentication required")
}
var user storage.UserEntity
err := storage.GlobalStore.View(func(tx storage.ReadOnlyTx) error {
found, ok := tx.GetUser(userID)
if !ok {
return common.NotFound("no user with provided credentials exist")
}
user = found
return nil
})
user, err := h.store.GetUserByID(c.Context(), userID)
if err != nil {
return common.SendAppError(c, err)
}
-41
View File
@@ -1,41 +0,0 @@
package users
import (
"time"
"gitflic.ru/project/bulla-max/mtusi2026lab1/internal/common"
"github.com/google/uuid"
)
type User struct {
ID uuid.UUID `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt common.RFCFormTime `json:"created_at"`
}
type CreateUserRequest struct {
Username string `json:"username" validate:"required"`
DisplayName string `json:"display_name" validate:"required"`
}
func NewUser(req CreateUserRequest) User {
return User{
ID: uuid.New(),
Username: req.Username,
DisplayName: req.DisplayName,
CreatedAt: common.NowUTC(),
}
}
func (u User) GetID() uuid.UUID {
return u.ID
}
func (u User) GetCreatedAt() time.Time {
return time.Time(u.CreatedAt)
}
func (u User) GetUsername() string {
return u.Username
}
+10 -5
View File
@@ -1,11 +1,16 @@
package users
import "github.com/gofiber/fiber/v3"
import (
"gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store"
"github.com/gofiber/fiber/v3"
)
func RegisterPublicRoutes(router fiber.Router) {
router.Post("/users", createUser)
func RegisterPublicRoutes(router fiber.Router, st *store.Store) {
handler := NewHandler(st)
router.Post("/users", handler.CreateUser)
}
func RegisterRoutes(router fiber.Router) {
router.Get("/users/me", getCurrentUser)
func RegisterRoutes(router fiber.Router, st *store.Store) {
handler := NewHandler(st)
router.Get("/users/me", handler.GetCurrentUser)
}
+96
View File
@@ -0,0 +1,96 @@
# AGENT: Single local stack for lab 2 grade 4. PostgreSQL is the source of
# truth, Redis stores sessions with AOF persistence. Both have named volumes,
# so `docker compose restart` preserves data and `down -v` is never needed.
name: mtusi2026lab2
x-api-environment: &api-environment
APP_HOST: 0.0.0.0
APP_PORT: "8080"
DB_POOL_MAX_CONNS: ${DB_POOL_MAX_CONNS:-10}
DATABASE_URL: postgres://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger}?sslmode=disable
CACHE_URL: redis://redis:6379/0
services:
postgres:
image: postgres:16.10-alpine
restart: unless-stopped
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
POSTGRES_DB: ${POSTGRES_DB:-messenger}
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 3s
timeout: 3s
retries: 20
start_period: 5s
redis:
image: redis:7.4.7-alpine
restart: unless-stopped
# AOF survives a container restart and keeps absolute key TTLs, which is
# exactly what the session-persistence check needs.
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec", "--save", ""]
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 3s
retries: 20
start_period: 3s
api:
build:
context: .
dockerfile: Dockerfile
restart: unless-stopped
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
environment:
<<: *api-environment
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
ports:
- "${APP_PORT_PUBLISH:-8080}:8080"
healthcheck:
test: ["CMD", "wget", "-q", "-O", "-", "http://127.0.0.1:8080/health/ready"]
interval: 5s
timeout: 4s
retries: 12
start_period: 15s
stop_grace_period: 15s
# AGENT: Only for the short-TTL expiry check. It shares PostgreSQL and Redis
# with the main API, so its 2-second sessions are visible to every instance.
api-short-ttl:
profiles: ["checks"]
build:
context: .
dockerfile: Dockerfile
restart: unless-stopped
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
environment:
<<: *api-environment
SESSION_TTL_SECONDS: "2"
ports:
- "${APP_SHORT_TTL_PORT:-8081}:8080"
healthcheck:
test: ["CMD", "wget", "-q", "-O", "-", "http://127.0.0.1:8080/health/ready"]
interval: 5s
timeout: 4s
retries: 12
start_period: 15s
stop_grace_period: 15s
volumes:
pgdata:
redisdata:
+14
View File
@@ -0,0 +1,14 @@
# Environment and fixed versions
date_utc: 2026-10-20T13:35:48Z
kernel: Linux 6.12.73+deb13-amd64 x86_64
cpus: 4
memory: 7.5Gi
go_module: go version go1.27.1 linux/amd64
python: Python 3.12.3
docker_client: 29.9.1
docker_server: 29.3.0
compose: 5.6.0
images:
postgres:16.10-alpine
redis:7.4.7-alpine
mtusi2026lab2-api
+3
View File
@@ -0,0 +1,3 @@
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+14
View File
@@ -0,0 +1,14 @@
$ cd app && go build ./... && go vet ./... && go test ./...
? gitflic.ru/project/bulla-max/mtusi2026lab2/cmd/server [no test files]
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal [no test files]
ok gitflic.ru/project/bulla-max/mtusi2026lab2/internal/auth (cached)
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/chats [no test files]
ok gitflic.ru/project/bulla-max/mtusi2026lab2/internal/common (cached)
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/config [no test files]
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/database [no test files]
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/health [no test files]
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/messages [no test files]
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/model [no test files]
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/session [no test files]
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/store [no test files]
? gitflic.ru/project/bulla-max/mtusi2026lab2/internal/users [no test files]
+3
View File
@@ -0,0 +1,3 @@
$ make validate PYTHON=/tmp/lab2-venv/bin/python
/tmp/lab2-venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
+9
View File
@@ -0,0 +1,9 @@
$ docker compose --env-file .env config --quiet
OK: compose file and .env are valid
$ docker compose --env-file .env config --services
redis
postgres
api
$ docker compose --env-file .env config --volumes
pgdata
redisdata
+3
View File
@@ -0,0 +1,3 @@
$ make test BASE_URL=http://172.18.0.1:8080
python3 tests/smoke.py --base-url "http://172.18.0.1:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+32
View File
@@ -0,0 +1,32 @@
# Persistence hook scope: real container restarts, volumes preserved
$ docker inspect before
/api started=2026-10-20T13:43:34.744581601Z restarts=0
/postgres started=2026-10-20T13:45:47.006469682Z restarts=0
/redis started=2026-10-20T13:45:33.276541726Z restarts=0
$ make test-persistence BASE_URL=http://172.18.0.1:8080 ACTION_SCRIPT=scripts/restart.sh
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://172.18.0.1:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
$ docker inspect after
/api started=2026-10-20T13:46:01.985254148Z restarts=0
/postgres started=2026-10-20T13:46:00.989433719Z restarts=0
/redis started=2026-10-20T13:46:01.023470617Z restarts=0
$ docker compose ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab2-api-1 sha256:4e5079fddfd7792f1ccf90891259fc4d737a8486a7a92461dcd72c6b0fd6914d "/usr/local/bin/serv…" api 2 minutes ago Up 5 seconds (healthy) 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
mtusi2026lab2-api-short-ttl-1 mtusi2026lab2-api-short-ttl "/usr/local/bin/serv…" api-short-ttl 2 minutes ago Up 2 minutes (healthy) 0.0.0.0:8081->8080/tcp, [::]:8081->8080/tcp
mtusi2026lab2-postgres-1 postgres:16.10-alpine "docker-entrypoint.s…" postgres 10 minutes ago Up 6 seconds (healthy) 5432/tcp
mtusi2026lab2-redis-1 redis:7.4.7-alpine "docker-entrypoint.s…" redis 10 minutes ago Up 6 seconds (healthy) 6379/tcp
$ docker volume ls (project volumes)
mtusi2026lab2_pgdata
mtusi2026lab2_redisdata
$ redis AOF files
total 20
-rw------- 1 redis redis 88 Oct 20 13:35 appendonly.aof.1.base.rdb
-rw------- 1 redis redis 11185 Oct 20 13:46 appendonly.aof.1.incr.aof
-rw------- 1 redis redis 88 Oct 20 13:35 appendonly.aof.manifest
+27
View File
@@ -0,0 +1,27 @@
$ docker compose --env-file .env --profile checks up -d --wait api-short-ttl
Container mtusi2026lab2-postgres-1 Running
Container mtusi2026lab2-redis-1 Running
Container mtusi2026lab2-api-short-ttl-1 Running
Container mtusi2026lab2-redis-1 Waiting
Container mtusi2026lab2-postgres-1 Waiting
Container mtusi2026lab2-postgres-1 Healthy
Container mtusi2026lab2-redis-1 Healthy
Container mtusi2026lab2-redis-1 Waiting
Container mtusi2026lab2-api-short-ttl-1 Waiting
Container mtusi2026lab2-postgres-1 Waiting
Container mtusi2026lab2-api-short-ttl-1 Healthy
Container mtusi2026lab2-redis-1 Healthy
Container mtusi2026lab2-postgres-1 Healthy
$ python3 scripts/grade4_checks.py --base-url http://172.18.0.1:8080 --short-ttl-url http://172.18.0.1:8081
PASS: wrong password -> 401 with Basic challenge
PASS: logout revoked the current token (repeat -> 401)
PASS: X-User-Id is ignored and grants no access
PASS: 12 concurrent registrations of one username -> one 201, eleven 409
PASS: failed composite chat creation rolled back completely
PASS: SESSION_TTL_SECONDS=2 session expired and was rejected by the main API
PASS: redis down: live=200, ready=503, protected=503 (bounded unavailable error, no anonymous access; detected in 4.4s)
PASS: redis recovered in 4.0s; same token and confirmed message intact
PASS: postgres down: live=200, ready=503, protected=503 (bounded unavailable error, session retained; detected in 2.8s)
PASS: postgres recovered in 0.9s; same token and confirmed message intact
PASS: grade 4 checks completed
+35
View File
@@ -0,0 +1,35 @@
$ ./scripts/seed_and_explain.sh
INSERT 0 0
INSERT 0 0
INSERT 0 0
DELETE 10000
INSERT 0 10000
VACUUM
seeded_messages
-----------------
10000
(1 row)
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..7.03 rows=51 width=70) (actual time=0.018..0.037 rows=51 loops=1)
Buffers: shared hit=6
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.41..1298.32 rows=9999 width=70) (actual time=0.017..0.032 rows=51 loops=1)
Index Cond: ((chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'::uuid) AND (ROW(created_at, id) > ROW('0001-01-01 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Buffers: shared hit=6
Planning:
Buffers: shared hit=18
Planning Time: 0.208 ms
Execution Time: 0.104 ms
(9 rows)
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..7.83 rows=51 width=70) (actual time=0.039..0.054 rows=51 loops=1)
Buffers: shared hit=5
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.41..1055.85 rows=7259 width=70) (actual time=0.038..0.049 rows=51 loops=1)
Index Cond: ((chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 01:23:20+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Buffers: shared hit=5
Planning Time: 0.073 ms
Execution Time: 0.087 ms
(7 rows)
+18
View File
@@ -0,0 +1,18 @@
$ python3 tests/load.py --base-url http://172.18.0.1:8080 --duration 10 --concurrency 4 --output evidence/load.json
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 10.0,
"elapsed_seconds": 10.089,
"concurrency": 4,
"successful_requests": 8854,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 877.599,
"successful_latency_ms": {
"p50": 4.06,
"p95": 7.835,
"p99": 10.654
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+17
View File
@@ -0,0 +1,17 @@
$ docker compose --env-file .env --profile checks ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab2-api-1 sha256:4e5079fddfd7792f1ccf90891259fc4d737a8486a7a92461dcd72c6b0fd6914d "/usr/local/bin/serv…" api 3 minutes ago Up 22 seconds (healthy) 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
mtusi2026lab2-api-short-ttl-1 mtusi2026lab2-api-short-ttl "/usr/local/bin/serv…" api-short-ttl 3 minutes ago Up 3 minutes (healthy) 0.0.0.0:8081->8080/tcp, [::]:8081->8080/tcp
mtusi2026lab2-postgres-1 postgres:16.10-alpine "docker-entrypoint.s…" postgres 10 minutes ago Up 23 seconds (healthy) 5432/tcp
mtusi2026lab2-redis-1 redis:7.4.7-alpine "docker-entrypoint.s…" redis 10 minutes ago Up 23 seconds (healthy) 6379/tcp
$ curl -s -o /dev/null -w "%{http_code} %{content_type}\\n" http://172.18.0.1:8080/health/ready
200 application/json; charset=utf-8
$ docker volume ls --filter name=mtusi2026lab2
DRIVER VOLUME NAME
local mtusi2026lab2_pgdata
local mtusi2026lab2_redisdata
$ redis-cli --scan --pattern "messenger:session:*" | wc -l
46
+66
View File
@@ -0,0 +1,66 @@
$ docker compose --env-file .env exec -T postgres psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -c "\\d users" -c "\\d chats" -c "\\d chat_members" -c "\\d messages" -c "TABLE schema_migrations"
Table "public.users"
Column | Type | Collation | Nullable | Default
---------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
username | text | | not null |
display_name | text | | not null |
password_hash | text | | not null |
created_at | timestamp with time zone | | not null |
Indexes:
"users_pkey" PRIMARY KEY, btree (id)
"users_username_key" UNIQUE CONSTRAINT, btree (username)
Check constraints:
"users_display_name_len" CHECK (char_length(display_name) >= 1 AND char_length(display_name) <= 100)
"users_username_format" CHECK (username ~ '^[a-z0-9_]{3,32}$'::text)
Referenced by:
TABLE "chat_members" CONSTRAINT "chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE RESTRICT
TABLE "messages" CONSTRAINT "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE RESTRICT
Table "public.chats"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
title | text | | not null |
created_at | timestamp with time zone | | not null |
Indexes:
"chats_pkey" PRIMARY KEY, btree (id)
Check constraints:
"chats_title_len" CHECK (char_length(title) >= 1 AND char_length(title) <= 100)
Referenced by:
TABLE "chat_members" CONSTRAINT "chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
TABLE "messages" CONSTRAINT "messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
Table "public.chat_members"
Column | Type | Collation | Nullable | Default
---------+------+-----------+----------+---------
chat_id | uuid | | not null |
user_id | uuid | | not null |
Indexes:
"chat_members_pkey" PRIMARY KEY, btree (chat_id, user_id)
"chat_members_user_idx" btree (user_id, chat_id)
Foreign-key constraints:
"chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE RESTRICT
Table "public.messages"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
chat_id | uuid | | not null |
sender_id | uuid | | not null |
text | text | | not null |
created_at | timestamp with time zone | | not null |
Indexes:
"messages_pkey" PRIMARY KEY, btree (id)
"messages_chat_created_id_idx" btree (chat_id, created_at, id)
Check constraints:
"messages_text_len" CHECK (char_length(text) >= 1 AND char_length(text) <= 4000)
Foreign-key constraints:
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE RESTRICT
version | applied_at
---------------+-----------------------------
0001_init.sql | 2026-10-20 13:35:37.6134+00
(1 row)
+17
View File
@@ -0,0 +1,17 @@
# Git hygiene: no secrets, volumes or build artifacts tracked
$ git ls-files | grep -E "(^|/)\\.env$|app/tmp|volumes/|(^|/)server$" || echo "OK: none tracked"
OK: none tracked
$ git check-ignore -v .env
.gitignore:2:.env .env
$ git status --short
(empty after this evidence commit)
$ git log --oneline --decorate -3
0b37e16 (HEAD -> master, tag: lab2-green) Реализовать лабораторную 2: PostgreSQL, Redis-сессии, keyset и проверки уровня 4
65003b6 (origin/master, origin/HEAD) Подготовить skeleton лабораторной 2 по мессенджеру
4c14ccb Первый коммит
$ git tag --list
lab2-green
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 10.0,
"elapsed_seconds": 10.089,
"concurrency": 4,
"successful_requests": 8854,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 877.599,
"successful_latency_ms": {
"p50": 4.06,
"p95": 7.835,
"p99": 10.654
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+203
View File
@@ -0,0 +1,203 @@
#!/usr/bin/env python3
"""Grade 4 checks that the public smoke does not cover.
Covers: concurrent duplicate registration, atomic chat rollback, short TTL
expiry, logout invalidation, wrong password, and Redis/PostgreSQL outage
behaviour. Failure drills use `docker compose stop/start` and never remove
volumes. Tokens, passwords and hook output are not printed.
"""
import argparse
import concurrent.futures
import os
from pathlib import Path
import subprocess
import sys
import time
import uuid
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, Failure, check # noqa: E402
def say(message):
print("PASS: " + message, flush=True)
def compose(args, *command):
env_file = ROOT / ".env"
check(env_file.is_file(), ".env is missing; copy .env.example to .env")
full = [
"docker", "compose",
"--env-file", str(env_file),
"-p", args.compose_project,
"-f", str((ROOT / args.compose_file).resolve()),
*command,
]
result = subprocess.run(full, cwd=ROOT, stdout=subprocess.DEVNULL,
stderr=subprocess.PIPE, text=True, timeout=60)
if result.returncode != 0:
# stderr may contain paths, never credentials in normal compose output.
raise Failure("docker compose " + command[0] + " failed: " + result.stderr.strip()[:300])
def readiness(client):
try:
client.call("GET", "/health/ready", 200, schema="Health")
return 200
except Failure:
try:
client.call("GET", "/health/ready", 503)
return 503
except Failure:
return None
def wait_for(client, expected, seconds=45):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
if readiness(client) == expected:
return
time.sleep(0.5)
raise Failure("/health/ready did not become " + str(expected))
def check_wrong_password(args):
client = Client(args.base_url)
actor = client.user("wrongpw")
registration = actor["registration"]
credential = _basic(registration["username"], "definitely-wrong-password")
response = client.call("POST", "/api/v1/auth/sessions", 401,
headers={"Authorization": "Basic " + credential})
check(response["headers"].get("WWW-Authenticate", "").lower().startswith("basic"),
"wrong password did not return a Basic challenge")
say("wrong password -> 401 with Basic challenge")
def check_logout(args):
client = Client(args.base_url)
actor = client.user("logout")
client.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=actor)
client.call("GET", "/api/v1/users/me", 401, actor=actor)
say("logout revoked the current token (repeat -> 401)")
def check_x_user_id(args):
client = Client(args.base_url)
alice = client.user("xalice")
bob = client.user("xbob")
me = client.call("GET", "/api/v1/users/me", actor=alice,
headers={"X-User-Id": bob["id"]}, schema="User")["json"]
check(me["id"] == alice["id"], "X-User-Id overrode bearer identity")
client.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": alice["id"]})
say("X-User-Id is ignored and grants no access")
def check_concurrent_registration(args):
username = "race_" + uuid.uuid4().hex[:12]
body = {"username": username, "display_name": "Race", "password": "concurrent-password-123"}
def register(_):
client = Client(args.base_url)
response = client.call("POST", "/api/v1/users", (201, 409), body=body)
return response["status"]
with concurrent.futures.ThreadPoolExecutor(max_workers=12) as pool:
statuses = list(pool.map(register, range(12)))
check(statuses.count(201) == 1, "expected exactly one 201, got " + str(statuses.count(201)))
check(statuses.count(409) == 11, "expected eleven 409, got " + str(statuses.count(409)))
say("12 concurrent registrations of one username -> one 201, eleven 409")
def check_chat_rollback(args):
client = Client(args.base_url)
actor = client.user("rollback")
title = "rollback-" + uuid.uuid4().hex
unknown = str(uuid.uuid4())
client.call("POST", "/api/v1/chats", 400, actor=actor,
body={"title": title, "member_ids": [actor["id"], unknown]})
page = client.call("GET", "/api/v1/chats?limit=100", actor=actor, schema="ChatPage")["json"]
check(all(chat["title"] != title for chat in page["items"]),
"failed chat creation left a partial chat behind")
say("failed composite chat creation rolled back completely")
def check_short_ttl(args):
check(args.short_ttl_url, "--short-ttl-url is required for the expiry check")
short = Client(args.short_ttl_url)
main = Client(args.base_url)
actor = short.user("ttl")
main.call("GET", "/api/v1/users/me", actor=actor, schema="User")
time.sleep(3.5)
main.call("GET", "/api/v1/users/me", 401, actor=actor)
say("SESSION_TTL_SECONDS=2 session expired and was rejected by the main API")
def drill(args, client, actor, chat, message, service, expected_message):
started = time.monotonic()
compose(args, "stop", service)
wait_for(client, 503, 45)
detection = time.monotonic() - started
client.call("GET", "/health/live", 200, schema="Health")
client.call("GET", "/health/ready", 503)
client.call("GET", "/api/v1/users/me", 503, actor=actor)
say("%s down: live=200, ready=503, protected=503 (%s; detected in %.1fs)"
% (service, expected_message, detection))
started = time.monotonic()
compose(args, "start", service)
wait_for(client, 200, 60)
recovery = time.monotonic() - started
client.call("GET", "/api/v1/users/me", actor=actor, schema="User")
page = client.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100",
actor=actor, schema="MessagePage")["json"]
check(any(item == message for item in page["items"]),
service + " recovery lost a confirmed message")
say("%s recovered in %.1fs; same token and confirmed message intact" % (service, recovery))
def check_failure_drills(args):
client = Client(args.base_url)
actor = client.user("drill")
chat = client.call("POST", "/api/v1/chats", 201, actor=actor,
body={"title": "Failure drill", "member_ids": [actor["id"]]},
schema="Chat")["json"]
message = client.message(actor, chat, "drill-persist-" + uuid.uuid4().hex)["json"]
drill(args, client, actor, chat, message, "redis", "bounded unavailable error, no anonymous access")
drill(args, client, actor, chat, message, "postgres", "bounded unavailable error, session retained")
def _basic(username, password):
import base64
return base64.b64encode((username + ":" + password).encode("utf-8")).decode("ascii")
def main():
parser = argparse.ArgumentParser(description="Lab 2 grade 4 evidence checks")
parser.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://localhost:8080"))
parser.add_argument("--short-ttl-url", default=os.environ.get("SHORT_TTL_URL", "http://localhost:8081"))
parser.add_argument("--compose-project", default=os.environ.get("COMPOSE_PROJECT_NAME", "mtusi2026lab2"))
parser.add_argument("--compose-file", default="compose.yaml")
parser.add_argument("--skip-failure", action="store_true", help="skip Redis/PostgreSQL stop drills")
args = parser.parse_args()
check_wrong_password(args)
check_logout(args)
check_x_user_id(args)
check_concurrent_registration(args)
check_chat_rollback(args)
check_short_ttl(args)
if not args.skip_failure:
check_failure_drills(args)
print("PASS: grade 4 checks completed")
if __name__ == "__main__":
try:
main()
except Failure as error:
print("FAIL:", str(error))
raise SystemExit(1)
+24
View File
@@ -0,0 +1,24 @@
#!/bin/sh
# AGENT: Restart hook for tests/resilience.py. It intentionally uses `restart`,
# never `down -v`, `flushall` or a re-seed: PostgreSQL data and the Redis AOF
# stay on their named volumes. Exit 0 means "the restart was requested", the
# test then waits for /health/ready and reuses the existing bearer token.
set -eu
cd "$(dirname "$0")/.."
COMPOSE_FILE_PATH="${COMPOSE_FILE:-compose.yaml}"
if [ ! -f .env ]; then
echo "restart.sh: .env is missing; copy .env.example to .env first" >&2
exit 2
fi
compose() {
docker compose --env-file .env -f "$COMPOSE_FILE_PATH" "$@"
}
# State stores first, then the API, so the app reconnects to a live database.
# The API itself retries PostgreSQL for up to 30 seconds during startup.
compose restart postgres redis
compose restart api
+53
View File
@@ -0,0 +1,53 @@
-- Synthetic history for the index evidence. Never run this against real data:
-- it deletes only messages of the dedicated seed chat and re-creates them.
\set ON_ERROR_STOP on
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ('aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', 'seed_10k', 'Seed 10k',
'not-a-login-hash', '2026-01-01T00:00:00Z')
ON CONFLICT (id) DO NOTHING;
INSERT INTO chats (id, title, created_at)
VALUES ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', 'Seed 10k history', '2026-01-01T00:00:00Z')
ON CONFLICT (id) DO NOTHING;
INSERT INTO chat_members (chat_id, user_id)
VALUES ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa')
ON CONFLICT DO NOTHING;
DELETE FROM messages WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
'seed message ' || g,
'2026-01-01T00:00:00Z'::timestamptz + (g || ' seconds')::interval
FROM generate_series(1, 10000) AS g;
-- Remove index entries left by the previous seed run; without this the plan
-- reads dead entries and the buffer count reflects history, not page depth.
VACUUM (ANALYZE) messages;
SELECT count(*) AS seeded_messages
FROM messages
WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
-- First page: the same predicate the API sends with an empty cursor.
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'
AND (created_at, id) > ('0001-01-01T00:00:00Z'::timestamptz, '00000000-0000-0000-0000-000000000000'::uuid)
ORDER BY created_at, id
LIMIT 51;
-- Deep page: the cursor points at message 5000, so a correct plan seeks there
-- instead of scanning the first 5000 rows.
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'
AND (created_at, id) > ('2026-01-01T01:23:20Z'::timestamptz, '00000000-0000-0000-0000-000000000000'::uuid)
ORDER BY created_at, id
LIMIT 51;
+21
View File
@@ -0,0 +1,21 @@
#!/bin/sh
# AGENT: Seeds exactly 10,000 synthetic messages into a dedicated chat and runs
# EXPLAIN (ANALYZE, BUFFERS) using the API's keyset predicate. Output goes to
# stdout so it can be stored in evidence/explain.txt.
set -eu
cd "$(dirname "$0")/.."
if [ ! -f .env ]; then
echo "seed_and_explain.sh: .env is missing" >&2
exit 2
fi
set -a
# shellcheck disable=SC1091
. ./.env
set +a
docker compose --env-file .env exec -T postgres \
psql -v ON_ERROR_STOP=1 -U "${POSTGRES_USER}" -d "${POSTGRES_DB}" \
< scripts/seed_10k.sql