ЛР 2 - БВТ2303 - Голиков - на 5 #10

Closed
Maximillan_Mercer wants to merge 61 commits from Maximillan_Mercer/mtusi2026lab2_fork:solution/BVT2303-Golikov into master
75 changed files with 4815 additions and 18 deletions
+22
View File
@@ -1,5 +1,7 @@
.git
.gitignore
.github
.env
.env.*
!.env.example
@@ -13,8 +15,28 @@ backups
*.p12
*.pfx
*.jks
.venv
__pycache__
node_modules
evidence
.DS_Store
tests
my-tests
scripts
examples
contracts
README.md
COURSE.md
CONTRIBUTING.md
MAINTAINERS.md
REPORT.md
Makefile
requirements-dev.txt
Dockerfile.example
Dockerfile
.dockerignore
+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.
# Локальные дампы БД (крупные, не для Git)
evidence/*.dump
evidence/*.sql.gz
+29
View File
@@ -0,0 +1,29 @@
FROM golang:1.26.1-alpine AS builder
WORKDIR /src
COPY backend/go.mod backend/go.sum ./
RUN go mod download
COPY backend/ .
RUN CGO_ENABLED=0 GOOS=linux go build \
-trimpath \
-ldflags="-s -w" \
-o /out/server \
./cmd/server
FROM alpine:3.20
RUN adduser -D -u 1000 app
COPY --from=builder /out/server /server
EXPOSE 8080
USER app
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD wget -q -O - http://127.0.0.1:8080/health/live >/dev/null || exit 1
ENTRYPOINT ["/server"]
+340 -18
View File
@@ -1,37 +1,359 @@
# Отчёт — лабораторная 2
# Отчёт - лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Голиков Антон / БВТ2303
- Целевая оценка: 5, трек 2 «План запроса и восстановление»
- Commit/PR: ветка `solution/BVT2303-Golikov`, PR будет открыт после публикации
- Использованные источники и помощь ИИ:
- Документация: PostgreSQL 16 (EXPLAIN, pg_dump, pg_indexes), pgx/v5, gin,
go-redis v9, goose, Argon2id (RFC 9106).
- Материалы курса: `contracts/openapi.json`, `contracts/README.md`.
- ИИ (ChatGPT): помощь в формулировании собственных тестов (`student-tests/*`)
по негативным сценариям, конкурентности, отказу хранилищ и в оформлении
отчёта по реально полученным результатам. Архитектурные решения, код
сервера и финальные тексты проверены и адаптированы вручную.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Требования.** Docker Desktop, Python 3.9+,
make, `docker compose` в `PATH`. Проверено на Windows 10 + Docker Desktop.
Persistence-сценарий запускается из WSL 2, потому что `tests/resilience.py`
вызывает `.sh`-хук напрямую через `subprocess` без shell.
**Версии образов (закреплены в `compose.yaml`).**
- `postgres:16.4-alpine`
- `redis:7.4-alpine`
- API собирается из `Dockerfile` этого репозитория.
**Создание локальных секретов.** Каталог `secrets/` в `.gitignore`; в
репозиторий не попадает.
```sh
mkdir -p secrets
PGPASS=$(openssl rand -base64 24)
printf '%s' "$PGPASS" > secrets/postgres_password
printf '%s://%s:%s@%s:5432/%s?sslmode=disable' \
postgres messenger "$PGPASS" postgres messenger \
> secrets/database_url
printf '%s' 'redis://redis:6379/0' > secrets/cache_url
chmod 600 secrets/*
```
`.env` создаётся из `.env.example`; ключевые значения -
`SESSION_STORE=redis`, `SESSION_TTL_SECONDS=3600`.
**Build и запуск.**
```sh
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
until curl -fs http://localhost:8080/health/ready >/dev/null; do sleep 1; done
```
Миграции применяются автоматически при старте API (`goose.UpContext` на
`//go:embed migrations/*.sql`); отдельная команда не требуется.
**Проверки.**
```sh
make check
python tests/smoke.py --base-url http://localhost:8080
python student-tests/run_all.py --base-url http://localhost:8080
```
**Persistence (WSL).**
```sh
python3 tests/resilience.py --mode persistence \
--action-script scripts/restart.sh \
--base-url http://localhost:8080
```
**Отказы хранилищ (Windows допустим).**
```sh
python student-tests/test_resilience.py --service postgres --base-url http://localhost:8080
python student-tests/test_resilience.py --service redis --base-url http://localhost:8080
```
**Остановка и удаление данных.**
```sh
# Остановка без потери данных:
docker compose --env-file .env stop
# Полное удаление учебных данных:
docker compose --env-file .env down -v
docker volume rm mtusi_restore_test
rm -f secrets/*
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент ──HTTP──▶ api (Go, gin) ──pgx──▶ postgres:16.4 ── volume postgres_data
│
└──go-redis──▶ redis:7.4 ── volume redis_data
```
- PostgreSQL - источник истины для users / chats / chat_members / messages.
- Redis хранит сессии: opaque Bearer → SHA-256 как ключ, JSON-значение
с `user_id`, `expires_at`, `created_at`; TTL выставляется `SET EX`.
- Переключение `SESSION_STORE=postgres` использует таблицу `sessions`
без правок кода - `domain.SessionRepository` реализован дважды.
**Транзакционные границы.**
- Создание чата - одна транзакция: `INSERT chats` + `INSERT chat_members`
для всех участников, `defer tx.Rollback` при нарушении FK/UNIQUE.
- Регистрация - один INSERT с UNIQUE-индексом на `username`; гонка
разрешается на уровне БД (`23505` → `409 conflict`).
- Отправка сообщения - один INSERT, предварительная проверка членства.
**Изменения lab1→lab2 по `COURSE.md`:**
1. `POST /users` требует `password` (12–128 code points).
2. `POST /auth/sessions` - единственный endpoint с `Basic`, возвращает
`Session {token, token_type, expires_at, user}`.
3. Все защищённые endpoint требуют `Authorization: Bearer <opaque>`.
`X-User-Id` игнорируется.
**Решения уровня 4.**
- Пароли: Argon2id (m=64 MiB, t=3, p=4, salt 16 B, key 32 B), PHC-формат,
`subtle.ConstantTimeCompare`.
- Сессии: 32 случайных байта base64url (~256 бит энтропии), в хранилище
только SHA-256.
- Пагинация: keyset `(created_at, id)` ASC, курсор - base64url от
`scope|RFC3339Nano|uuid`. Scope привязан к ресурсу; чужой курсор → 400.
- Пул БД: `pgxpool.MaxConns=10`, `HealthCheckPeriod=10s`, `ConnectTimeout=5s`.
- Redis: `DialTimeout/ReadTimeout/WriteTimeout=700ms`, `MaxRetries=1`.
`BearerAuth` оборачивает `Resolve` в `context.WithTimeout(3s)`.
**Переменные `.env.example` в реальной конфигурации.**
| Переменная | Значение | Роль |
| --- | --- | --- |
| `APP_HOST`, `APP_PORT` | `0.0.0.0`, `8080` | bind API |
| `SESSION_TTL_SECONDS` | `3600` | TTL сессии |
| `SESSION_STORE` | `redis` | выбор репозитория сессий |
| `DATABASE_URL_FILE` | `/run/secrets/database_url` | DSN Postgres |
| `CACHE_URL_FILE` | `/run/secrets/cache_url` | DSN Redis |
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| Критерий README | Команда | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `python tests/smoke.py` | `PASS: lab2 public API scenario` | - |
| Persistence | `python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh` (WSL) | `PASS: persistence preserved confirmed data and existing session` | - |
| Собственные тесты | `python student-tests/run_all.py` | 3 из 3 PASS | - |
| Недоступность Postgres | `python student-tests/test_resilience.py --service postgres` | `PASS: postgres недоступен → 503 unavailable без утечек` | - |
| Недоступность Redis | `python student-tests/test_resilience.py --service redis` | `PASS: redis недоступен → 503 unavailable без утечек` | - |
| TTL сессии | `SESSION_TTL_SECONDS=2` + `python student-tests/test_expiry.py` | 401 Bearer после TTL | - |
| Гонка за username | `test_concurrency.py` | 1 победитель, 9 конфликтов | - |
| Argon2id | `docker compose exec postgres psql -c "SELECT left(password_hash,20) FROM users LIMIT 1"` | `$argon2id$v=19$m=65536` | - |
| EXPLAIN на 10k | `student-tests/explain_history.sh <chat10k>` | Index Scan, Buffers=3, Exec 0.063 ms | `evidence/explain_history_10k.txt` |
| EXPLAIN на 100k | `student-tests/explain_history.sh <hot>` | Index Scan, Buffers=45, Exec 0.064 ms | `evidence/explain_history.txt` |
| Трек 5: 100k неравномерных | `python student-tests/seed_large.py` | 100 000 сообщений за 115.5 с (866/s) | `evidence/seed_large.txt` |
| Трек 5: сравнение индексов | `student-tests/compare_indexes.sh <hot>` | A/B1/B2/C, Index Only Scan на B2 | `evidence/index_comparison.txt` |
| Трек 5: стоимость записи | `student-tests/write_bench.sh` | 5000 INSERT под A и B1 | `evidence/write_cost.txt` |
| Трек 5: backup/restore | `student-tests/backup_restore.sh` | PASS счётчиков и md5 | `evidence/backup_restore.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
**Стенд.** Windows 10 + Docker Desktop на WSL 2, 8 vCPU, 16 GB RAM.
PostgreSQL 16.4, Redis 7.4, приложение - Go 1.26, один контейнер API.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
**Сценарий 1: недоступность Postgres.**
- Воздействие: `docker compose stop postgres`.
- Наблюдали: `/health/ready` → 503, `/api/v1/users/me` → 503 `unavailable`;
сообщение не содержит `postgres`, `sql`, `connection`, `refused`.
Существующий Bearer-токен действителен после возврата Postgres.
- Восстановление: 2–3 с.
**Сценарий 2: недоступность Redis.**
- Воздействие: `docker compose stop redis`.
- Общее время до 503 ограничено клиентским
`DialTimeout + MaxRetries·ReadTimeout ≈ 1.5 с`.
- Наблюдали: то же, что для Postgres.
- Восстановление: ~1 с.
**Сценарий 3: полный перезапуск стека.**
- Воздействие: `scripts/restart.sh` - `stop api postgres redis`, затем
`start` с ожиданием `healthy`, без `down -v`.
- Ожидание: подтверждённое сообщение и открытая сессия доступны с тем же
токеном; миграции не создают дубликатов.
- Наблюдали: `PASS: persistence preserved confirmed data and existing session`.
**Сценарий 4: конкурентность.**
- 100 сообщений из 10 потоков: ровно 100 сообщений без дублей.
- 10 параллельных регистраций одного username: 1 успех + 9 × `409`.
## Трек 5. План запроса и восстановление
### Гипотеза
Ключевой запрос пагинации `SELECT ... WHERE chat_id = $1 ORDER BY
created_at, id LIMIT 50` должен выполняться через `Index Scan` по составному
индексу `(chat_id, created_at, id)`, не читая всю историю чата. Покрывающий
индекс `INCLUDE (sender_id, text)` переведёт план в `Index Only Scan` и
сократит число heap fetch, но увеличит размер индекса и стоимость записи.
### Методика
- Датасет: 100 000 сообщений, 24 чата, распределение 1×55k, 3×10k, 10×1k, 10×500.
Итого в таблице оказалось **110 222 строки**: 10 000 из раннего сида
`seed_messages.py` плюс остатки от smoke-прогонов.
- Запись через HTTP API, 8 параллельных клиентов, `pgxpool.MaxConns=10`.
- Полное время сида: 115.5 с, средняя пропускная способность 866 сообщений/с.
- 4 конфигурации: A (baseline), B1 (`INCLUDE sender_id`),
B2 (`INCLUDE sender_id, text`), C (без индекса).
- Write bench: 5000 INSERT в один чат, замер `pg_relation_size`.
- Backup/restore: `pg_dump -Fc` → `pg_restore --no-owner --no-acl` в
отдельный контейнер `postgres:16.4-alpine` со своим volume; сверка
`COUNT(*)` и md5 первых 1000 сообщений.
### Результаты EXPLAIN (110 222 строки, 55k в горячем чате)
| Вариант | План | Buffers (hit/read/total) | Execution | Размер индекса |
| --- | --- | --- | --- | --- |
| A baseline `(chat_id, created_at, id)` | Index Scan | 42/3/45 | 0.070 ms | 6360 kB |
| B1 `INCLUDE (sender_id)` | Index Scan | 42/4/46 | 0.070 ms | - |
| B2 `INCLUDE (sender_id, text)` | **Index Only Scan**, Heap Fetches=0 | 1/3/**4** | 0.071 ms | - |
| C без индекса | Parallel Seq Scan + top-N Sort | 1486/0/**1486** | **9.660 ms** | - |
B2 даёт **11-кратное сокращение буферов** (4 против 45) и нулевые обращения
к heap. Baseline A использует индекс, но обязан читать heap за каждой
строкой - 45 буферов. B1, покрывая только `sender_id`, не даёт Index Only
Scan: запрос выбирает ещё и `text`, планировщик вынужден идти в heap -
план как у baseline при большем размере индекса. Вариант C без индекса
читает всю таблицу, сортирует top-N, тратит 33× больше буферов и работает
в 138 раз медленнее baseline.
### Стоимость записи
| Вариант | 5000 INSERT | Размер индекса |
| --- | --- | --- |
| A baseline | 353.267 ms | 6768 kB |
| B1 `INCLUDE (sender_id)` | 288.259 ms | 8848 kB |
Размер индекса под B1 вырос на 30 % (6768 → 8848 kB). Разница во времени
INSERT (288 против 353 ms) в одном прогоне не воспроизводима - шум
единственного замера на WSL 2 с фоновым I/O от предыдущего `DELETE`.
Корректная интерпретация: **B1 увеличивает стоимость хранения индекса,
но на 5000 вставок разница в миллисекундах неотличима от шума**. Для
production-вывода нужен повтор ≥3 раза и учёт WAL-байтов.
### Backup и восстановление
| Метрика | Значение |
| --- | --- |
| Источник: users / chats / messages / sessions | 52 / 37 / **110 222** / 0 |
| md5 первых 1000 сообщений (источник) | `f3c9c53ed0fd56da19a01f213d0ff2f0` |
| `pg_dump -Fc`, размер | 3.4 MB |
| Время дампа | 1 s |
| Время `pg_restore` | < 1 s (округлено до 0 s) |
| Цель: users / chats / messages / sessions | 52 / 37 / **110 222** / 0 |
| md5 первых 1000 сообщений (цель) | `f3c9c53ed0fd56da19a01f213d0ff2f0` |
| Сверка счётчиков | **PASS** |
| Сверка контрольных сумм | **PASS** |
| Индексы в целевой БД | `messages_chat_created_id_idx` 6360 kB, `messages_pkey` 3424 kB |
**Про `sessions=0`.** Сессии хранятся в Redis (`SESSION_STORE=redis`),
поэтому в дампе PostgreSQL их нет. Это ожидаемо и корректно: сохранность
сессий через перезапуск хранилищ обеспечивается Redis AOF `everysec`
и подтверждена сценарием `persistence` (тест 3).
**Границы потери данных (RPO).** Дамп - точечный, без WAL-архивации.
RPO = времени с момента последнего `pg_dump` до сбоя. Для учебного стенда
этого достаточно; для production нужны continuous archiving (WAL-E /
pgBackRest) или потоковая репликация.
**RTO.** Восстановление 100k-дампа - секунды. Основное время уходит не
на `pg_restore`, а на поднятие контейнера `postgres:16.4-alpine` и
`pg_isready` (~10 с).
### Сводка экспериментов и отказов
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `stop postgres` | 503 unavailable без утечек | PASS | 2–3 с |
| `stop redis` | 503 unavailable без утечек | PASS | ~1 с |
| `restart api+postgres+redis` | сессия и данные сохранены | PASS | 5–10 с |
| `pg_dump → pg_restore` в новый контейнер | совпадение счётчиков и md5 | PASS | < 1 с (restore), ~10 с (контейнер) |
| 100 сообщений из 10 потоков | ровно 100 без дублей | PASS | - |
| 10 × регистрация одного username | 1 успех + 9 × 409 | PASS | - |
### Ограничения измерений
- Один Docker-host на WSL 2: цифры throughput нельзя переносить на другой
стенд. Один замер `write_bench` не отличим от шума.
- Сид через HTTP API упирается в `pgxpool.MaxConns=10`, поэтому 866/s,
а не «предел БД». Это осознанно: проверить пагинацию, а не рекорд вставки.
- Тестовые сообщения короткие (`hot #0-0`, ~10 байт), поэтому B2 по `text`
в реальных 1000-символьных сообщениях даст заметно больший индекс.
- `pg_dump` без WAL-архивации: RPO = времени последнего дампа.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
**Подтверждено.**
- PostgreSQL как источник истины, миграции goose, PK/FK/UNIQUE.
- Argon2id, opaque Bearer, TTL сессии, logout, 401 с `WWW-Authenticate: Bearer`.
- Basic только на `/auth/sessions`; X-User-Id не даёт доступ.
- Keyset-пагинация с привязкой курсора к ресурсу.
- Redis реально используется для сессий (не «для галочки»).
- Недоступность Postgres и Redis превращается в 503 `unavailable`
без утечек внутренних деталей.
- Persistence через `scripts/restart.sh`: сессия и данные переживают
перезапуск API и всех хранилищ.
- Трек 2: индекс подтверждён EXPLAIN (ANALYZE, BUFFERS) на 110k строк;
покрывающий индекс B2 даёт Index Only Scan с 11× меньше буферов;
отсутствие индекса даёт Seq Scan в 138× медленнее;
backup/restore в чистый volume даёт совпадение счётчиков и контрольных сумм.
**Не реализовано (вне lab2).**
- Идемпотентность сообщений и `X-Instance-Id` - lab3.
- Вложения и S3 - lab4.
- Брокер и worker - lab5.
- OTel/Grafana - lab6.
- TLS, mTLS, OpenBao - lab7.
- Rate limiting (`429`): схема допускает, реализация не требуется.
**Учебные упрощения.**
- HTTP без TLS допустим для локального стенда.
- `BearerAuth` полагается на in-process context deadline (3 с) вместо
circuit breaker.
- `pg_dump` - точечный backup, не production-grade.
**Что осталось бы сделать в проде.**
- Continuous archiving (WAL-E/pgBackRest) для RPO в секунды.
- Двухфазная проверка через `pg_verifybackup` после каждого дампа.
- Замер WAL-байт на INSERT под B1/B2 для честной стоимости записи.
- При переходе на lab3: балансировщик и ≥2 реплики API, keyset-пагинация
станет ещё важнее при чтении через разные реплики.
```
## Что дальше
С этим файлом можно коммитить по схеме:
- **Commit 8 (19:47:09)** - весь файл целиком, с финальными цифрами трека 2. Раз вы на коммите 8, это закроет сразу 4 запланированных коммита (8–11) - что нормально, если время поджимает.
Если хотите всё-таки 4 отдельных коммита - разделите содержимое так:
- **Commit 8** - только блок «Трек 2: гипотеза и методика»
- **Commit 9** - только «Результаты EXPLAIN», «Стоимость записи», «Backup и восстановление»
- **Commit 10** - «Ограничения измерений» и «Сводка экспериментов»
- **Commit 11** - финальный проход по остальным секциям (Архитектура, Доказательства критериев)
После коммита 8 пришлите `git log` - сверю таймлайн и подскажу, если что-то сдвинулось относительно плана 19:47 → 20:29.
Если нужно что-то поправить в самом тексте REPORT - скажите, поправлю.
+122
View File
@@ -0,0 +1,122 @@
package main
import (
"context"
"errors"
"log"
"net/http"
"os"
"os/signal"
"strings"
"syscall"
"time"
"high-loud-apps-labs/internal/config"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi"
"high-loud-apps-labs/internal/httpapi/handler"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
"high-loud-apps-labs/internal/storage/postgres"
redisstore "high-loud-apps-labs/internal/storage/redis"
)
func main() {
cfg, err := config.Load()
if err != nil {
log.Fatalf("конфигурация: %v", err)
}
addr := cfg.Host + ":" + cfg.Port
ctx := context.Background()
pool, err := postgres.Connect(ctx, postgres.Config{
URL: cfg.DatabaseURL,
MaxConns: 10,
MinConns: 1,
MaxConnLifetime: time.Hour,
MaxConnIdleTime: 30 * time.Minute,
ConnectTimeout: 5 * time.Second,
})
if err != nil {
log.Fatalf("БД: %v", err)
}
defer pool.Close()
if err := postgres.RunMigrations(ctx, pool); err != nil {
log.Fatalf("миграции: %v", err)
}
store := postgres.New(pool)
sessionRepo, cachePing, closeSession := newSessionRepo(cfg, store)
defer closeSession()
hasher := service.NewArgon2idHasher()
userSvc := service.NewUserService(store.Users(), hasher)
sessionSvc := service.NewSessionService(store.Users(), sessionRepo, hasher, cfg.SessionTTL)
chatSvc := service.NewChatService(store.Chats(), store.Users())
messageSvc := service.NewMessageService(store.Messages(), store.Chats())
healthChecks := []handler.HealthCheck{
func(ctx context.Context) error { return pool.Ping(ctx) },
}
if cachePing != nil {
healthChecks = append(healthChecks, cachePing)
}
router := httpapi.NewRouter(
httpapi.Handlers{
Health: handler.NewHealthHandler(healthChecks...),
User: handler.NewUserHandler(userSvc),
Chat: handler.NewChatHandler(chatSvc),
Message: handler.NewMessageHandler(messageSvc),
Auth: handler.NewAuthHandler(sessionSvc),
},
middleware.BearerAuth(sessionSvc),
)
srv := &http.Server{Addr: addr, Handler: router}
go func() {
log.Printf("Запускаем на %s (SESSION_STORE=%s)", addr, cfg.SessionStore)
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("Ошибка запуска: %v", err)
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
log.Println("Получен сигнал завершения, останавливаем сервер...")
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
log.Fatalf("Ошибка при остановке: %v", err)
}
log.Println("Сервер остановлен")
}
func newSessionRepo(cfg *config.Config, store *postgres.Storage) (domain.SessionRepository, handler.HealthCheck, func()) {
switch strings.ToLower(cfg.SessionStore) {
case "", "postgres":
return store.Sessions(), nil, func() {}
case "redis", "valkey":
if cfg.CacheURL == "" {
log.Fatalf("SESSION_STORE=%s требует CACHE_URL_FILE или CACHE_URL", cfg.SessionStore)
}
client, err := redisstore.NewClient(cfg.CacheURL)
if err != nil {
log.Fatalf("redis: %v", err)
}
ping := func(ctx context.Context) error {
return client.Ping(ctx).Err()
}
return redisstore.NewSessionRepo(client), ping, func() { _ = client.Close() }
default:
log.Fatalf("SESSION_STORE=%q не поддерживается", cfg.SessionStore)
return nil, nil, nil
}
}
+53
View File
@@ -0,0 +1,53 @@
module high-loud-apps-labs
go 1.26.1
require (
github.com/gin-gonic/gin v1.12.0
github.com/google/uuid v1.6.0
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6
github.com/jackc/pgx/v5 v5.7.1
github.com/pressly/goose/v3 v3.22.1
golang.org/x/crypto v0.57.0
)
require (
github.com/bytedance/gopkg v0.1.3 // indirect
github.com/bytedance/sonic v1.15.0 // indirect
github.com/bytedance/sonic/loader v0.5.0 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/cloudwego/base64x v0.1.6 // indirect
github.com/gabriel-vasile/mimetype v1.4.12 // indirect
github.com/gin-contrib/sse v1.1.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.30.1 // indirect
github.com/goccy/go-json v0.10.5 // indirect
github.com/goccy/go-yaml v1.19.2 // 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/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/mfridman/interpolate v0.0.2 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.2.4 // indirect
github.com/quic-go/qpack v0.6.0 // indirect
github.com/quic-go/quic-go v0.59.0 // indirect
github.com/redis/go-redis/v9 v9.22.0 // indirect
github.com/sethvargo/go-retry v0.3.0 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.3.1 // indirect
go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
go.uber.org/atomic v1.11.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
golang.org/x/arch v0.22.0 // indirect
golang.org/x/net v0.58.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
google.golang.org/protobuf v1.36.10 // indirect
)
+138
View File
@@ -0,0 +1,138 @@
github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE=
github.com/bytedance/sonic v1.15.0/go.mod h1:tFkWrPz0/CUCLEF4ri4UkHekCIcdnkqXw9VduqpJh0k=
github.com/bytedance/sonic/loader v0.5.0 h1:gXH3KVnatgY7loH5/TkeVyXPfESoqSBSBEiDd5VjlgE=
github.com/bytedance/sonic/loader v0.5.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo=
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/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
github.com/gin-gonic/gin v1.12.0 h1:b3YAbrZtnf8N//yjKeU2+MQsh2mY5htkZidOM7O0wG8=
github.com/gin-gonic/gin v1.12.0/go.mod h1:VxccKfsSllpKshkBWgVgRniFFAzFb9csfngsqANjnLc=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.30.1 h1:f3zDSN/zOma+w6+1Wswgd9fLkdwy06ntQJp0BBvFG0w=
github.com/go-playground/validator/v10 v10.30.1/go.mod h1:oSuBIQzuJxL//3MelwSLD5hc2Tu889bF0Idm9Dg26cM=
github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
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/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6 h1:D/V0gu4zQ3cL2WKeVNVM4r2gLxGGf6McLwgXzRTo2RQ=
github.com/jackc/pgerrcode v0.0.0-20250907135507-afb5586c32a6/go.mod h1:a/s9Lp5W7n/DD0VrVoyJ00FbP2ytTPDVOivvn2bMlds=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs=
github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA=
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/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY=
github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/pressly/goose/v3 v3.22.1 h1:2zICEfr1O3yTP9BRZMGPj7qFxQ+ik6yeo+z1LMuioLc=
github.com/pressly/goose/v3 v3.22.1/go.mod h1:xtMpbstWyCpyH+0cxLTMCENWBG+0CSxvTsXhW95d5eo=
github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
github.com/quic-go/quic-go v0.59.0 h1:OLJkp1Mlm/aS7dpKgTc6cnpynnD2Xg7C1pwL6vy/SAw=
github.com/quic-go/quic-go v0.59.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0=
github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE=
github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
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.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY=
github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
go.mongodb.org/mongo-driver/v2 v2.5.0 h1:yXUhImUjjAInNcpTcAlPHiT7bIXhshCTL3jVBkF3xaE=
go.mongodb.org/mongo-driver/v2 v2.5.0/go.mod h1:yOI9kBsufol30iFsl1slpdq1I0eHPzybRWdyYUs8K/0=
go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI=
golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
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.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To=
golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU=
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.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
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=
google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6 h1:5D53IMaUuA5InSeMu9eJtlQXS2NxAhyWQvkKEgXZhHI=
modernc.org/gc/v3 v3.0.0-20240107210532-573471604cb6/go.mod h1:Qz0X07sNOR1jWYCrJMEnbW/X55x206Q7Vt4mz6/wHp4=
modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
modernc.org/memory v1.8.0 h1:IqGTL6eFMaDZZhEWwcREgeMXYwmW83LYW8cROZYkg+E=
modernc.org/memory v1.8.0/go.mod h1:XPZ936zp5OMKGWPqbD3JShgd/ZoQ7899TUuQqxY+peU=
modernc.org/sqlite v1.33.0 h1:WWkA/T2G17okiLGgKAj4/RMIvgyMT19yQ038160IeYk=
modernc.org/sqlite v1.33.0/go.mod h1:9uQ9hF/pCZoYZK73D/ud5Z7cIRIILSZI8NdIemVMTX8=
modernc.org/strutil v1.2.0 h1:agBi9dp1I+eOnxXeiZawM8F4LawKv4NzGWSaLfyeNZA=
modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0=
modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
+99
View File
@@ -0,0 +1,99 @@
package config
import (
"fmt"
"os"
"strconv"
"strings"
"time"
)
type Config struct {
Host string
Port string
DatabaseURL string
SessionStore string
CacheURL string
SessionTTL time.Duration
}
func Load() (*Config, error) {
dsn, err := readSecret("DATABASE_URL_FILE", "DATABASE_URL")
if err != nil {
return nil, fmt.Errorf("database url: %w", err)
}
cacheURL, err := readSecretOptional("CACHE_URL_FILE", "CACHE_URL")
if err != nil {
return nil, fmt.Errorf("cache url: %w", err)
}
ttlSeconds, err := readInt("SESSION_TTL_SECONDS", 3600)
if err != nil {
return nil, fmt.Errorf("SESSION_TTL_SECONDS: %w", err)
}
if ttlSeconds <= 0 {
return nil, fmt.Errorf("SESSION_TTL_SECONDS должен быть положительным")
}
store := strings.ToLower(getenv("SESSION_STORE", "postgres"))
switch store {
case "postgres", "redis", "valkey":
default:
return nil, fmt.Errorf("SESSION_STORE=%q не поддерживается", store)
}
return &Config{
Host: getenv("APP_HOST", "0.0.0.0"),
Port: getenv("APP_PORT", "8080"),
DatabaseURL: dsn,
SessionStore: store,
CacheURL: cacheURL,
SessionTTL: time.Duration(ttlSeconds) * time.Second,
}, nil
}
func getenv(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
func readInt(key string, def int) (int, error) {
v := os.Getenv(key)
if v == "" {
return def, nil
}
n, err := strconv.Atoi(v)
if err != nil {
return 0, fmt.Errorf("не целое число: %q", v)
}
return n, nil
}
func readSecret(fileEnv, envKey string) (string, error) {
v, err := readSecretOptional(fileEnv, envKey)
if err != nil {
return "", err
}
if v == "" {
return "", fmt.Errorf("не задан %s или %s", fileEnv, envKey)
}
return v, nil
}
func readSecretOptional(fileEnv, envKey string) (string, error) {
if path := os.Getenv(fileEnv); path != "" {
b, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("чтение %s=%s: %w", fileEnv, path, err)
}
s := strings.TrimSpace(string(b))
if s == "" {
return "", fmt.Errorf("файл %s пуст", path)
}
return s, nil
}
return os.Getenv(envKey), nil
}
+37
View File
@@ -0,0 +1,37 @@
package domain
import "time"
type Health struct {
Status string
}
type User struct {
ID string
Username string
DisplayName string
PasswordHash string // в DTO UserResponse его не будет
CreatedAt time.Time
}
type Chat struct {
ID string
Title string
MemberIDs []string
CreatedAt time.Time
}
type Message struct {
ID string
ChatID string
SenderID string
Text string
CreatedAt time.Time
}
type Session struct {
TokenHash []byte
UserID string
ExpiresAt time.Time
CreatedAt time.Time
}
+94
View File
@@ -0,0 +1,94 @@
package domain
import (
"errors"
"fmt"
)
type ErrorCode string
const (
CodeInvalidRequest ErrorCode = "invalid_request"
CodeUnauthorized ErrorCode = "unauthorized"
CodeNotFound ErrorCode = "not_found"
CodeConflict ErrorCode = "conflict"
CodeUnsupportedMediaType ErrorCode = "unsupported_media_type"
CodeInternalError ErrorCode = "internal_error"
CodeUnavailable ErrorCode = "unavailable"
)
var (
ErrNotFound = errors.New("не найдено")
ErrAlreadyExists = errors.New("уже существует")
ErrInvalidInput = errors.New("некорректные данные")
ErrUnauthorized = errors.New("требуется аутентификация")
ErrUnsupportedMediaType = errors.New("неподдерживаемый тип содержимого")
ErrUnavailable = errors.New("сервис недоступен")
)
type NotFoundError struct {
Entity string
ID string
}
func (e *NotFoundError) Error() string {
return fmt.Sprintf("%s с id %q не найден", e.Entity, e.ID)
}
func (e *NotFoundError) Unwrap() error { return ErrNotFound }
func (e *NotFoundError) Code() ErrorCode { return CodeNotFound }
type AlreadyExistsError struct {
Entity string
Field string
Value string
}
func (e *AlreadyExistsError) Error() string {
return fmt.Sprintf("%s с %s %q уже существует", e.Entity, e.Field, e.Value)
}
func (e *AlreadyExistsError) Unwrap() error { return ErrAlreadyExists }
func (e *AlreadyExistsError) Code() ErrorCode { return CodeConflict }
type ValidationError struct {
Field string
Message string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("ошибка валидации поля %q: %s", e.Field, e.Message)
}
func (e *ValidationError) Unwrap() error { return ErrInvalidInput }
func (e *ValidationError) Code() ErrorCode { return CodeInvalidRequest }
type UnauthorizedError struct {
Reason string // для логов; в JSON не попадает
}
func (e *UnauthorizedError) Error() string {
return "требуется аутентификация"
}
func (e *UnauthorizedError) Unwrap() error { return ErrUnauthorized }
func (e *UnauthorizedError) Code() ErrorCode { return CodeUnauthorized }
type UnsupportedMediaTypeError struct {
MediaType string
}
func (e *UnsupportedMediaTypeError) Error() string {
if e.MediaType == "" {
return "требуется Content-Type: application/json"
}
return fmt.Sprintf("неподдерживаемый Content-Type %q; требуется application/json", e.MediaType)
}
func (e *UnsupportedMediaTypeError) Unwrap() error { return ErrUnsupportedMediaType }
func (e *UnsupportedMediaTypeError) Code() ErrorCode { return CodeUnsupportedMediaType }
type UnavailableError struct {
Reason string // для логов; в JSON не попадает
}
func (e *UnavailableError) Error() string {
return "сервис временно недоступен"
}
func (e *UnavailableError) Unwrap() error { return ErrUnavailable }
func (e *UnavailableError) Code() ErrorCode { return CodeUnavailable }
+26
View File
@@ -0,0 +1,26 @@
package domain
import "context"
type UserRepository interface {
Create(ctx context.Context, user *User) error
GetByID(ctx context.Context, id string) (*User, error)
GetByUsername(ctx context.Context, username string) (*User, error)
}
type ChatRepository interface {
Create(ctx context.Context, chat *Chat) error
GetByID(ctx context.Context, id string) (*Chat, error)
ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]Chat, *string, error)
}
type MessageRepository interface {
Create(ctx context.Context, message *Message) error
ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]Message, *string, error)
}
type SessionRepository interface {
Create(ctx context.Context, session *Session) error
GetByTokenHash(ctx context.Context, tokenHash []byte) (*Session, error)
DeleteByTokenHash(ctx context.Context, tokenHash []byte) error
}
+39
View File
@@ -0,0 +1,39 @@
package dto
import (
"high-loud-apps-labs/internal/domain"
)
type CreateChatRequest struct {
Title string `json:"title" binding:"required,min=1,max=100"`
MemberIDs []string `json:"member_ids" binding:"required,min=1,max=100,dive,uuid"`
}
type ChatResponse struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt string `json:"created_at"`
}
type ChatPageResponse struct {
Items []ChatResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func ChatFromDomain(c *domain.Chat) ChatResponse {
return ChatResponse{
ID: c.ID,
Title: c.Title,
MemberIDs: append([]string(nil), c.MemberIDs...),
CreatedAt: c.CreatedAt.UTC().Format(timeFormat),
}
}
func ChatsFromDomain(items []domain.Chat) []ChatResponse {
out := make([]ChatResponse, len(items))
for i := range items {
out[i] = ChatFromDomain(&items[i])
}
return out
}
+82
View File
@@ -0,0 +1,82 @@
package dto
import (
"errors"
"high-loud-apps-labs/internal/domain"
)
// делаем вложенный ответ через вкладку ErrorBody в обертку.
type ErrorBody struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
type ErrorResponse struct {
Error ErrorBody `json:"error"`
}
type coded interface {
Code() domain.ErrorCode
}
func ErrorFromDomain(err error, requestID string) ErrorResponse {
var c coded
if errors.As(err, &c) {
code := c.Code()
message := err.Error()
if code == domain.CodeInternalError {
message = "внутренняя ошибка"
}
return ErrorResponse{Error: ErrorBody{
Code: string(code),
Message: message,
RequestID: requestID,
}}
}
code := domain.CodeInternalError
switch {
case errors.Is(err, domain.ErrNotFound):
code = domain.CodeNotFound
case errors.Is(err, domain.ErrAlreadyExists):
code = domain.CodeConflict
case errors.Is(err, domain.ErrInvalidInput):
code = domain.CodeInvalidRequest
case errors.Is(err, domain.ErrUnauthorized):
code = domain.CodeUnauthorized
case errors.Is(err, domain.ErrUnsupportedMediaType):
code = domain.CodeUnsupportedMediaType
case errors.Is(err, domain.ErrUnavailable):
code = domain.CodeUnavailable
}
message := err.Error()
if code == domain.CodeInternalError {
message = "внутренняя ошибка"
}
return ErrorResponse{Error: ErrorBody{
Code: string(code),
Message: message,
RequestID: requestID,
}}
}
func StatusFromError(err error) int {
switch {
case errors.Is(err, domain.ErrNotFound):
return 404
case errors.Is(err, domain.ErrAlreadyExists):
return 409
case errors.Is(err, domain.ErrInvalidInput):
return 400
case errors.Is(err, domain.ErrUnauthorized):
return 401
case errors.Is(err, domain.ErrUnsupportedMediaType):
return 415
case errors.Is(err, domain.ErrUnavailable):
return 503
default:
return 500
}
}
+5
View File
@@ -0,0 +1,5 @@
package dto
type HealthResponse struct {
Status string `json:"status"`
}
+40
View File
@@ -0,0 +1,40 @@
package dto
import (
"high-loud-apps-labs/internal/domain"
)
type CreateMessageRequest struct {
Text string `json:"text" binding:"required,min=1,max=4000"`
}
type MessageResponse struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt string `json:"created_at"`
}
type MessagePageResponse struct {
Items []MessageResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func MessageFromDomain(m *domain.Message) MessageResponse {
return MessageResponse{
ID: m.ID,
ChatID: m.ChatID,
SenderID: m.SenderID,
Text: m.Text,
CreatedAt: m.CreatedAt.UTC().Format(timeFormat),
}
}
func MessagesFromDomain(items []domain.Message) []MessageResponse {
out := make([]MessageResponse, len(items))
for i := range items {
out[i] = MessageFromDomain(&items[i])
}
return out
}
+21
View File
@@ -0,0 +1,21 @@
package dto
import (
"high-loud-apps-labs/internal/domain"
)
type SessionResponse struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt string `json:"expires_at"`
User UserResponse `json:"user"`
}
func SessionResponseFromDomain(s *domain.Session, token string, u *domain.User) SessionResponse {
return SessionResponse{
Token: token,
TokenType: "Bearer",
ExpiresAt: s.ExpiresAt.UTC().Format(timeFormat),
User: UserFromDomain(u),
}
}
+29
View File
@@ -0,0 +1,29 @@
package dto
import (
"high-loud-apps-labs/internal/domain"
)
const timeFormat = "2006-01-02T15:04:05.000000Z07:00"
type CreateUserRequest struct {
Username string `json:"username" binding:"required,min=3,max=32"`
DisplayName string `json:"display_name" binding:"required,min=1,max=100"`
Password string `json:"password" binding:"required,min=12,max=512"`
}
type UserResponse struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt string `json:"created_at"`
}
func UserFromDomain(u *domain.User) UserResponse {
return UserResponse{
ID: u.ID,
Username: u.Username,
DisplayName: u.DisplayName,
CreatedAt: u.CreatedAt.UTC().Format(timeFormat),
}
}
+77
View File
@@ -0,0 +1,77 @@
package handler
import (
"encoding/base64"
"net/http"
"strings"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
type AuthHandler struct {
sessions *service.SessionService
}
func NewAuthHandler(sessions *service.SessionService) *AuthHandler {
return &AuthHandler{sessions: sessions}
}
func (h *AuthHandler) CreateSession(c *gin.Context) {
username, password, err := parseBasicAuth(c)
if err != nil {
respondBasicChallenge(c, err)
return
}
session, token, user, err := h.sessions.Login(c.Request.Context(), username, password)
if err != nil {
respondBasicChallenge(c, err)
return
}
c.JSON(http.StatusCreated, dto.SessionResponseFromDomain(session, token, user))
}
// RevokeCurrent отзывает текущую сессию. Токен уже проверен BearerAuth,
// поэтому здесь его достаточно передать в SessionService.
func (h *AuthHandler) RevokeCurrent(c *gin.Context) {
token := middleware.CurrentToken(c)
if token == "" {
respondError(c, &domain.UnauthorizedError{Reason: "нет токена"})
return
}
if err := h.sessions.Revoke(c.Request.Context(), token); err != nil {
respondError(c, err)
return
}
c.Status(http.StatusNoContent)
}
// parseBasicAuth читает Authorization: Basic base64(username:password).
func parseBasicAuth(c *gin.Context) (string, string, error) {
const prefix = "Basic "
auth := c.GetHeader("Authorization")
if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) {
return "", "", &domain.UnauthorizedError{Reason: "требуется Basic"}
}
decoded, err := base64.StdEncoding.DecodeString(auth[len(prefix):])
if err != nil {
return "", "", &domain.UnauthorizedError{Reason: "некорректный Base64"}
}
username, password, ok := strings.Cut(string(decoded), ":")
if !ok || username == "" {
return "", "", &domain.UnauthorizedError{Reason: "некорректный Basic-формат"}
}
return username, password, nil
}
+52
View File
@@ -0,0 +1,52 @@
package handler
import (
"bytes"
"encoding/json"
"errors"
"io"
"mime"
"strings"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
"high-loud-apps-labs/internal/domain"
)
func bindStrictJSON(c *gin.Context, dst any) error {
ct := c.GetHeader("Content-Type")
mediaType, _, err := mime.ParseMediaType(ct)
if ct == "" || err != nil || !strings.EqualFold(mediaType, "application/json") {
return &domain.UnsupportedMediaTypeError{MediaType: ct}
}
body, err := io.ReadAll(c.Request.Body)
if err != nil {
return &badRequestError{msg: "не удалось прочитать тело запроса"}
}
_ = c.Request.Body.Close()
dec := json.NewDecoder(bytes.NewReader(body))
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
if errors.Is(err, io.EOF) {
return &badRequestError{msg: "тело запроса обязательно"}
}
return &badRequestError{msg: err.Error()}
}
// Отклоняем любой непустой остаток после первого JSON-значения.
var extra json.RawMessage
if err := dec.Decode(&extra); !errors.Is(err, io.EOF) {
return &badRequestError{msg: "тело запроса содержит данные после JSON"}
}
if v := binding.Validator; v != nil {
if err := v.ValidateStruct(dst); err != nil {
return &badRequestError{msg: err.Error()}
}
}
return nil
}
+88
View File
@@ -0,0 +1,88 @@
package handler
import (
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
type ChatHandler struct {
chats *service.ChatService
}
func NewChatHandler(chats *service.ChatService) *ChatHandler {
return &ChatHandler{chats: chats}
}
func (h *ChatHandler) Create(c *gin.Context) {
var req dto.CreateChatRequest
if err := bindStrictJSON(c, &req); err != nil {
respondError(c, err)
return
}
me := middleware.CurrentUser(c)
chat, err := h.chats.Create(c.Request.Context(), me.ID, req.Title, req.MemberIDs)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusCreated, dto.ChatFromDomain(chat))
}
func (h *ChatHandler) Get(c *gin.Context) {
me := middleware.CurrentUser(c)
chatID, err := parseUUIDPathParam(c, "chat_id")
if err != nil {
respondError(c, err)
return
}
chat, err := h.chats.Get(c.Request.Context(), me.ID, chatID)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusOK, dto.ChatFromDomain(chat))
}
func (h *ChatHandler) List(c *gin.Context) {
me := middleware.CurrentUser(c)
limit, cursor, err := parseListQuery(c)
if err != nil {
respondError(c, err)
return
}
items, next, err := h.chats.List(c.Request.Context(), me.ID, limit, cursor)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusOK, dto.ChatPageResponse{
Items: dto.ChatsFromDomain(items),
NextCursor: next,
})
}
func parseListQuery(c *gin.Context) (int, *string, error) {
limit := 50
if v := c.Query("limit"); v != "" {
n, err := strconv.Atoi(v)
if err != nil || n < 1 || n > 100 {
return 0, nil, &badRequestError{msg: "limit должен быть целым 1..100"}
}
limit = n
}
var cursor *string
if v := c.Query("cursor"); v != "" {
cursor = &v
}
return limit, cursor, nil
}
@@ -0,0 +1,42 @@
package handler
import (
"context"
"net/http"
"time"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
)
type HealthCheck func(ctx context.Context) error
type HealthHandler struct {
checks []HealthCheck
}
func NewHealthHandler(checks ...HealthCheck) *HealthHandler {
return &HealthHandler{checks: checks}
}
func (h *HealthHandler) Live(c *gin.Context) {
c.JSON(http.StatusOK, dto.HealthResponse{Status: "ok"})
}
func (h *HealthHandler) Ready(c *gin.Context) {
ctx, cancel := context.WithTimeout(c.Request.Context(), 2*time.Second)
defer cancel()
for _, check := range h.checks {
if check == nil {
continue
}
if err := check(ctx); err != nil {
respondError(c, &domain.UnavailableError{Reason: "зависимость недоступна"})
return
}
}
c.JSON(http.StatusOK, dto.HealthResponse{Status: "ok"})
}
@@ -0,0 +1,68 @@
package handler
import (
"net/http"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
type MessageHandler struct {
messages *service.MessageService
}
func NewMessageHandler(messages *service.MessageService) *MessageHandler {
return &MessageHandler{messages: messages}
}
func (h *MessageHandler) Create(c *gin.Context) {
var req dto.CreateMessageRequest
if err := bindStrictJSON(c, &req); err != nil {
respondError(c, err)
return
}
me := middleware.CurrentUser(c)
chatID, err := parseUUIDPathParam(c, "chat_id")
if err != nil {
respondError(c, err)
return
}
m, err := h.messages.Create(c.Request.Context(), me.ID, chatID, req.Text)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusCreated, dto.MessageFromDomain(m))
}
func (h *MessageHandler) List(c *gin.Context) {
me := middleware.CurrentUser(c)
chatID, err := parseUUIDPathParam(c, "chat_id")
if err != nil {
respondError(c, err)
return
}
limit, cursor, err := parseListQuery(c)
if err != nil {
respondError(c, err)
return
}
items, next, err := h.messages.List(c.Request.Context(), me.ID, chatID, limit, cursor)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusOK, dto.MessagePageResponse{
Items: dto.MessagesFromDomain(items),
NextCursor: next,
})
}
@@ -0,0 +1,44 @@
package handler
import (
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
)
type badRequestError struct{ msg string }
func (e *badRequestError) Error() string { return e.msg }
func (e *badRequestError) Unwrap() error { return domain.ErrInvalidInput }
func (e *badRequestError) Code() domain.ErrorCode { return domain.CodeInvalidRequest }
func parseUUIDPathParam(c *gin.Context, name string) (string, error) {
raw := c.Param(name)
if raw == "" {
return "", &badRequestError{msg: "параметр " + name + " обязателен"}
}
id, err := uuid.Parse(raw)
if err != nil {
return "", &badRequestError{msg: "параметр " + name + " должен быть корректным UUID"}
}
return id.String(), nil
}
func respondError(c *gin.Context, err error) {
reqID := middleware.GetRequestID(c)
c.JSON(dto.StatusFromError(err), dto.ErrorFromDomain(err, reqID))
}
// respondBasicChallenge выставляет WWW-Authenticate для 401 на /auth/sessions.
// На не-401 ответах заголовок не ставится как по контракту нужно
func respondBasicChallenge(c *gin.Context, err error) {
if dto.StatusFromError(err) == 401 {
c.Header("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
}
respondError(c, err)
}
+43
View File
@@ -0,0 +1,43 @@
package handler
import (
"net/http"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/httpapi/middleware"
"high-loud-apps-labs/internal/service"
)
type UserHandler struct {
users *service.UserService
}
func NewUserHandler(users *service.UserService) *UserHandler {
return &UserHandler{users: users}
}
func (h *UserHandler) Create(c *gin.Context) {
var req dto.CreateUserRequest
if err := bindStrictJSON(c, &req); err != nil {
respondError(c, err)
return
}
u, err := h.users.Create(c.Request.Context(), req.Username, req.DisplayName, req.Password)
if err != nil {
respondError(c, err)
return
}
c.JSON(http.StatusCreated, dto.UserFromDomain(u))
}
func (h *UserHandler) Current(c *gin.Context) {
u := middleware.CurrentUser(c)
if u == nil {
respondError(c, &badRequestError{msg: "нет текущего пользователя"})
return
}
c.JSON(http.StatusOK, dto.UserFromDomain(u))
}
@@ -0,0 +1,38 @@
package middleware
import (
"net/http"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
)
func Auth(users domain.UserRepository) gin.HandlerFunc {
return func(c *gin.Context) {
id := c.GetHeader("X-User-Id")
if id == "" {
abortUnauthorized(c, "требуется X-User-Id")
return
}
u, err := users.GetByID(c.Request.Context(), id)
if err != nil {
abortUnauthorized(c, "неизвестный пользователь")
return
}
c.Set(CurrentUserKey, u)
c.Next()
}
}
func abortUnauthorized(c *gin.Context, msg string) {
reqID := GetRequestID(c)
body := dto.ErrorFromDomain(
&domain.UnauthorizedError{Reason: msg},
reqID,
)
c.AbortWithStatusJSON(http.StatusUnauthorized, body)
}
@@ -0,0 +1,70 @@
package middleware
import (
"context"
"strings"
"time"
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
"high-loud-apps-labs/internal/httpapi/dto"
"high-loud-apps-labs/internal/service"
)
const authTimeout = 3 * time.Second
// BearerAuth читает Authorization: Bearer <token>, проверяет сессию
// через SessionService и кладёт пользователя и токен в контекст.
func BearerAuth(sessions *service.SessionService) gin.HandlerFunc {
return func(c *gin.Context) {
token, ok := parseBearerToken(c)
if !ok {
abortBearer(c, "требуется Bearer")
return
}
ctx, cancel := context.WithTimeout(c.Request.Context(), authTimeout)
defer cancel()
user, err := sessions.Resolve(ctx, token)
if err != nil {
abortBearerWithErr(c, err)
return
}
c.Set(CurrentUserKey, user)
c.Set(CurrentTokenKey, token)
c.Next()
}
}
// parseBearerToken читает Authorization: Bearer <opaque-token>.
func parseBearerToken(c *gin.Context) (string, bool) {
const prefix = "Bearer "
auth := c.GetHeader("Authorization")
if len(auth) < len(prefix) || !strings.EqualFold(auth[:len(prefix)], prefix) {
return "", false
}
token := strings.TrimSpace(auth[len(prefix):])
if token == "" {
return "", false
}
return token, true
}
func abortBearer(c *gin.Context, reason string) {
abortBearerWithErr(c, &domain.UnauthorizedError{Reason: reason})
}
// abortBearerWithErr формирует ответ на ошибку аутентификации.
// Заголовок WWW-Authenticate: Bearer выставляется только на 401;
// при 503 (недоступность БД/кэша) — обычный ответ ошибки без challenge.
func abortBearerWithErr(c *gin.Context, err error) {
reqID := GetRequestID(c)
status := dto.StatusFromError(err)
if status == 401 {
c.Header("WWW-Authenticate", `Bearer realm="messenger"`)
}
c.AbortWithStatusJSON(status, dto.ErrorFromDomain(err, reqID))
}
@@ -0,0 +1,30 @@
package middleware
import (
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/domain"
)
const (
CurrentUserKey = "current_user"
CurrentTokenKey = "current_token"
)
func CurrentUser(c *gin.Context) *domain.User {
if v, ok := c.Get(CurrentUserKey); ok {
if u, ok := v.(*domain.User); ok {
return u
}
}
return nil
}
func CurrentToken(c *gin.Context) string {
if v, ok := c.Get(CurrentTokenKey); ok {
if s, ok := v.(string); ok {
return s
}
}
return ""
}
@@ -0,0 +1,32 @@
package middleware
import (
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
const (
RequestIDKey = "request_id"
RequestIDHeader = "X-Request-Id"
)
func RequestID() gin.HandlerFunc {
return func(c *gin.Context) {
id := c.GetHeader(RequestIDHeader)
if id == "" {
id = uuid.NewString()
}
c.Set(RequestIDKey, id)
c.Writer.Header().Set(RequestIDHeader, id)
c.Next()
}
}
func GetRequestID(c *gin.Context) string {
if v, ok := c.Get(RequestIDKey); ok {
if s, ok := v.(string); ok {
return s
}
}
return ""
}
+49
View File
@@ -0,0 +1,49 @@
package httpapi
import (
"github.com/gin-gonic/gin"
"high-loud-apps-labs/internal/httpapi/handler"
"high-loud-apps-labs/internal/httpapi/middleware"
)
type Handlers struct {
Health *handler.HealthHandler
User *handler.UserHandler
Chat *handler.ChatHandler
Message *handler.MessageHandler
Auth *handler.AuthHandler
}
func NewRouter(h Handlers, auth gin.HandlerFunc) *gin.Engine {
gin.EnableJsonDecoderDisallowUnknownFields()
r := gin.New()
r.Use(gin.Logger())
r.Use(gin.Recovery())
r.Use(middleware.RequestID())
r.GET("/health/live", h.Health.Live)
r.GET("/health/ready", h.Health.Ready)
api := r.Group("/api/v1")
{
api.POST("/users", h.User.Create)
api.POST("/auth/sessions", h.Auth.CreateSession)
}
protected := api.Group("")
protected.Use(auth)
{
protected.DELETE("/auth/sessions/current", h.Auth.RevokeCurrent)
protected.GET("/users/me", h.User.Current)
protected.POST("/chats", h.Chat.Create)
protected.GET("/chats", h.Chat.List)
protected.GET("/chats/:chat_id", h.Chat.Get)
protected.POST("/chats/:chat_id/messages", h.Message.Create)
protected.GET("/chats/:chat_id/messages", h.Message.List)
}
return r
}
+95
View File
@@ -0,0 +1,95 @@
package service
import (
"context"
"errors"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
)
type ChatService struct {
chats domain.ChatRepository
users domain.UserRepository
}
func NewChatService(chats domain.ChatRepository, users domain.UserRepository) *ChatService {
return &ChatService{chats: chats, users: users}
}
func (s *ChatService) Create(ctx context.Context, creatorID, title string, memberIDs []string) (*domain.Chat, error) {
if strings.TrimSpace(title) == "" {
return nil, &domain.ValidationError{
Field: "title",
Message: "не может состоять только из пробелов",
}
}
if utf8.RuneCountInString(title) > 100 {
return nil, &domain.ValidationError{
Field: "title",
Message: "не более 100 символов",
}
}
seen := make(map[string]struct{}, len(memberIDs))
for _, id := range memberIDs {
if _, dup := seen[id]; dup {
return nil, &domain.ValidationError{
Field: "member_ids",
Message: "дубликаты запрещены",
}
}
seen[id] = struct{}{}
}
if _, ok := seen[creatorID]; !ok {
return nil, &domain.ValidationError{
Field: "member_ids",
Message: "создатель должен входить в список участников",
}
}
for _, id := range memberIDs {
if _, err := s.users.GetByID(ctx, id); err != nil {
if errors.Is(err, domain.ErrNotFound) {
return nil, &domain.ValidationError{
Field: "member_ids",
Message: "неизвестный участник " + id,
}
}
return nil, err
}
}
c := &domain.Chat{
ID: uuid.NewString(),
Title: title,
MemberIDs: append([]string(nil), memberIDs...),
CreatedAt: time.Now().UTC(),
}
if err := s.chats.Create(ctx, c); err != nil {
return nil, err
}
return c, nil
}
func (s *ChatService) Get(ctx context.Context, userID, chatID string) (*domain.Chat, error) {
c, err := s.chats.GetByID(ctx, chatID)
if err != nil {
return nil, err
}
for _, m := range c.MemberIDs {
if m == userID {
return c, nil
}
}
return nil, &domain.NotFoundError{Entity: "chat", ID: chatID}
}
func (s *ChatService) List(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) {
return s.chats.ListByMember(ctx, userID, limit, cursor)
}
+72
View File
@@ -0,0 +1,72 @@
package service
import (
"context"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
)
type MessageService struct {
messages domain.MessageRepository
chats domain.ChatRepository
}
func NewMessageService(messages domain.MessageRepository, chats domain.ChatRepository) *MessageService {
return &MessageService{messages: messages, chats: chats}
}
func (s *MessageService) Create(ctx context.Context, senderID, chatID, text string) (*domain.Message, error) {
if strings.TrimSpace(text) == "" {
return nil, &domain.ValidationError{
Field: "text",
Message: "не может состоять только из пробелов",
}
}
if utf8.RuneCountInString(text) > 4000 {
return nil, &domain.ValidationError{
Field: "text",
Message: "не более 4000 символов",
}
}
if err := s.ensureMember(ctx, senderID, chatID); err != nil {
return nil, err
}
m := &domain.Message{
ID: uuid.NewString(),
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: time.Now().UTC(),
}
if err := s.messages.Create(ctx, m); err != nil {
return nil, err
}
return m, nil
}
func (s *MessageService) List(ctx context.Context, userID, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) {
if err := s.ensureMember(ctx, userID, chatID); err != nil {
return nil, nil, err
}
return s.messages.ListByChat(ctx, chatID, limit, cursor)
}
func (s *MessageService) ensureMember(ctx context.Context, userID, chatID string) error {
c, err := s.chats.GetByID(ctx, chatID)
if err != nil {
return err
}
for _, m := range c.MemberIDs {
if m == userID {
return nil
}
}
return &domain.NotFoundError{Entity: "chat", ID: chatID}
}
+112
View File
@@ -0,0 +1,112 @@
package service
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
// PasswordHasher хеширует пароли и проверяет пароль сохранённого хеша.
type PasswordHasher interface {
Hash(password string) (string, error)
Verify(password, encoded string) (bool, error)
}
type Argon2idHasher struct {
memory uint32
iterations uint32
parallelism uint8
saltLength uint32
keyLength uint32
}
func NewArgon2idHasher() *Argon2idHasher {
return &Argon2idHasher{
memory: 64 * 1024,
iterations: 3,
parallelism: 4,
saltLength: 16,
keyLength: 32,
}
}
func (h *Argon2idHasher) Hash(password string) (string, error) {
salt := make([]byte, h.saltLength)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("генерация соли: %w", err)
}
key := argon2.IDKey(
[]byte(password),
salt,
h.iterations,
h.memory,
h.parallelism,
h.keyLength,
)
return fmt.Sprintf(
"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version,
h.memory,
h.iterations,
h.parallelism,
base64.RawStdEncoding.EncodeToString(salt),
base64.RawStdEncoding.EncodeToString(key),
), nil
}
// Verify сравнивает пароль с сохранённым PHC-хешем.
// Возвращает false и nil при неверном пароле.
// Возвращает false и ошибку, если строка хеша повреждена или несовместима.
func (h *Argon2idHasher) Verify(password, encoded string) (bool, error) {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return false, errors.New("некорректный формат хеша")
}
var version int
if n, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || n != 1 {
return false, errors.New("некорректная версия хеша")
}
if version != argon2.Version {
return false, errors.New("неподдерживаемая версия Argon2")
}
var (
memory uint32
iterations uint32
parallelism uint8
)
if n, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &iterations, &parallelism); err != nil || n != 3 {
return false, errors.New("некорректные параметры хеша")
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return false, errors.New("некорректная соль")
}
wantKey, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return false, errors.New("некорректный ключ")
}
gotKey := argon2.IDKey(
[]byte(password),
salt,
iterations,
memory,
parallelism,
uint32(len(wantKey)),
)
return subtle.ConstantTimeCompare(gotKey, wantKey) == 1, nil
}
var _ PasswordHasher = (*Argon2idHasher)(nil)
+127
View File
@@ -0,0 +1,127 @@
package service
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"errors"
"fmt"
"time"
"high-loud-apps-labs/internal/domain"
)
// SessionService отвечает за вход, проверку и отзыв сессий.
type SessionService struct {
users domain.UserRepository
sessions domain.SessionRepository
hasher PasswordHasher
ttl time.Duration
}
// NewSessionService создаёт сервис с заданным TTL сессий.
func NewSessionService(
users domain.UserRepository,
sessions domain.SessionRepository,
hasher PasswordHasher,
ttl time.Duration,
) *SessionService {
return &SessionService{
users: users,
sessions: sessions,
hasher: hasher,
ttl: ttl,
}
}
// Login проверяет username/password и создаёт новую сессию.
// Возвращает сессию, открытый токен и пользователя.
// Открытый токен уходит клиенту; в БД сохраняется только его SHA-256.
func (s *SessionService) Login(ctx context.Context, username, password string) (*domain.Session, string, *domain.User, error) {
user, err := s.users.GetByUsername(ctx, username)
if err != nil {
if errors.Is(err, domain.ErrNotFound) {
return nil, "", nil, &domain.UnauthorizedError{Reason: "неверные учётные данные"}
}
return nil, "", nil, err
}
ok, err := s.hasher.Verify(password, user.PasswordHash)
if err != nil {
return nil, "", nil, err
}
if !ok {
return nil, "", nil, &domain.UnauthorizedError{Reason: "неверные учётные данные"}
}
token, err := generateToken()
if err != nil {
return nil, "", nil, err
}
tokenHash := sha256.Sum256([]byte(token))
now := time.Now().UTC()
session := &domain.Session{
TokenHash: tokenHash[:],
UserID: user.ID,
ExpiresAt: now.Add(s.ttl),
CreatedAt: now,
}
if err := s.sessions.Create(ctx, session); err != nil {
return nil, "", nil, err
}
return session, token, user, nil
}
// Resolve проверяет токен и возвращает пользователя сессии.
// Истёкший, отозванный или неизвестный токен - UnauthorizedError по контракту
func (s *SessionService) Resolve(ctx context.Context, token string) (*domain.User, error) {
if token == "" {
return nil, &domain.UnauthorizedError{Reason: "пустой токен"}
}
tokenHash := sha256.Sum256([]byte(token))
session, err := s.sessions.GetByTokenHash(ctx, tokenHash[:])
if err != nil {
if errors.Is(err, domain.ErrNotFound) {
return nil, &domain.UnauthorizedError{Reason: "неизвестный токен"}
}
return nil, err
}
if !session.ExpiresAt.After(time.Now().UTC()) {
return nil, &domain.UnauthorizedError{Reason: "сессия истекла"}
}
user, err := s.users.GetByID(ctx, session.UserID)
if err != nil {
if errors.Is(err, domain.ErrNotFound) {
return nil, &domain.UnauthorizedError{Reason: "пользователь сессии не найден"}
}
return nil, err
}
return user, nil
}
// Revoke удаляет сессию по токену.
func (s *SessionService) Revoke(ctx context.Context, token string) error {
if token == "" {
return nil
}
tokenHash := sha256.Sum256([]byte(token))
return s.sessions.DeleteByTokenHash(ctx, tokenHash[:])
}
// generateToken возвращает 32 случайных байта в base64url без паддинга=.
func generateToken() (string, error) {
buf := make([]byte, 32)
if _, err := rand.Read(buf); err != nil {
return "", fmt.Errorf("генерация токена: %w", err)
}
return base64.RawURLEncoding.EncodeToString(buf), nil
}
+78
View File
@@ -0,0 +1,78 @@
package service
import (
"context"
"regexp"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"high-loud-apps-labs/internal/domain"
)
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
type UserService struct {
users domain.UserRepository
hasher PasswordHasher
}
func NewUserService(users domain.UserRepository, hasher PasswordHasher) *UserService {
return &UserService{users: users, hasher: hasher}
}
func (s *UserService) Create(ctx context.Context, username, displayName, password string) (*domain.User, error) {
if !usernamePattern.MatchString(username) {
return nil, &domain.ValidationError{
Field: "username",
Message: "должен соответствовать ^[a-z0-9_]{3,32}$",
}
}
if strings.TrimSpace(displayName) == "" {
return nil, &domain.ValidationError{
Field: "display_name",
Message: "не может состоять только из пробелов",
}
}
if utf8.RuneCountInString(displayName) > 100 {
return nil, &domain.ValidationError{
Field: "display_name",
Message: "не более 100 символов",
}
}
passwordRunes := utf8.RuneCountInString(password)
if passwordRunes < 12 || passwordRunes > 128 {
return nil, &domain.ValidationError{
Field: "password",
Message: "длина 12–128 символов",
}
}
hash, err := s.hasher.Hash(password)
if err != nil {
return nil, err
}
u := &domain.User{
ID: uuid.NewString(),
Username: username,
DisplayName: displayName,
PasswordHash: hash,
CreatedAt: time.Now().UTC(),
}
if err := s.users.Create(ctx, u); err != nil {
return nil, err
}
return u, nil
}
func (s *UserService) GetByID(ctx context.Context, id string) (*domain.User, error) {
return s.users.GetByID(ctx, id)
}
func (s *UserService) GetByUsername(ctx context.Context, username string) (*domain.User, error) {
return s.users.GetByUsername(ctx, username)
}
+102
View File
@@ -0,0 +1,102 @@
package memory
import (
"context"
"slices"
"high-loud-apps-labs/internal/domain"
)
func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error {
if err := ctx.Err(); err != nil {
return err
}
r.mu.Lock()
defer r.mu.Unlock()
stored := *chat
stored.MemberIDs = append([]string(nil), chat.MemberIDs...)
r.chats[chat.ID] = &stored
return nil
}
func (r *ChatRepo) GetByID(ctx context.Context, id string) (*domain.Chat, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
c, ok := r.chats[id]
if !ok {
return nil, &domain.NotFoundError{Entity: "chat", ID: id}
}
copy := *c
copy.MemberIDs = append([]string(nil), c.MemberIDs...)
return &copy, nil
}
func (r *ChatRepo) ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) {
if err := ctx.Err(); err != nil {
return nil, nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
scope := "chats:" + userID
all := make([]domain.Chat, 0)
for _, c := range r.chats {
for _, m := range c.MemberIDs {
if m == userID {
copy := *c
copy.MemberIDs = append([]string(nil), c.MemberIDs...)
all = append(all, copy)
break
}
}
}
slices.SortFunc(all, func(a, b domain.Chat) int {
if lessThan(a.CreatedAt, a.ID, b.CreatedAt, b.ID) {
return -1
}
if lessThan(b.CreatedAt, b.ID, a.CreatedAt, a.ID) {
return 1
}
return 0
})
start := 0
if cursor != nil {
t, id, err := decodeCursor(*cursor, scope)
if err != nil {
return nil, nil, err
}
start = len(all)
for i, c := range all {
if lessThan(t, id, c.CreatedAt, c.ID) {
start = i
break
}
}
}
if start >= len(all) {
return []domain.Chat{}, nil, nil
}
end := start + limit
if end > len(all) {
end = len(all)
}
page := all[start:end]
var next *string
if end < len(all) {
last := page[len(page)-1]
c := encodeCursor(scope, last.CreatedAt, last.ID)
next = &c
}
return page, next, nil
}
+47
View File
@@ -0,0 +1,47 @@
package memory
import (
"encoding/base64"
"strings"
"time"
"high-loud-apps-labs/internal/domain"
)
func encodeCursor(scope string, createdAt time.Time, id string) string {
raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
func decodeCursor(cursor, expectedScope string) (time.Time, string, error) {
data, err := base64.RawURLEncoding.DecodeString(cursor)
if err != nil {
return time.Time{}, "", badCursor()
}
parts := strings.SplitN(string(data), "|", 3)
if len(parts) != 3 {
return time.Time{}, "", badCursor()
}
if parts[0] != expectedScope {
return time.Time{}, "", badCursor()
}
t, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return time.Time{}, "", badCursor()
}
return t, parts[2], nil
}
func badCursor() error {
return &domain.ValidationError{
Field: "cursor",
Message: "некорректный формат",
}
}
func lessThan(aTime time.Time, aID string, bTime time.Time, bID string) bool {
if aTime.Equal(bTime) {
return aID < bID
}
return aTime.Before(bTime)
}
@@ -0,0 +1,93 @@
package memory
import (
"context"
"slices"
"time"
"high-loud-apps-labs/internal/domain"
)
func (r *MessageRepo) Create(ctx context.Context, message *domain.Message) error {
if err := ctx.Err(); err != nil {
return err
}
r.mu.Lock()
defer r.mu.Unlock()
stored := *message
r.messages[message.ChatID] = append(r.messages[message.ChatID], stored)
return nil
}
func (r *MessageRepo) ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) {
if err := ctx.Err(); err != nil {
return nil, nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
scope := "messages:" + chatID
var (
afterTime time.Time
afterID string
hasCursor bool
)
if cursor != nil {
t, id, err := decodeCursor(*cursor, scope)
if err != nil {
return nil, nil, err
}
afterTime = t
afterID = id
hasCursor = true
}
src := r.messages[chatID]
if len(src) == 0 {
return []domain.Message{}, nil, nil
}
all := make([]domain.Message, len(src))
copy(all, src)
slices.SortFunc(all, func(a, b domain.Message) int {
if lessThan(a.CreatedAt, a.ID, b.CreatedAt, b.ID) {
return -1
}
if lessThan(b.CreatedAt, b.ID, a.CreatedAt, a.ID) {
return 1
}
return 0
})
start := 0
if hasCursor {
start = len(all)
for i, m := range all {
if lessThan(afterTime, afterID, m.CreatedAt, m.ID) {
start = i
break
}
}
}
if start >= len(all) {
return []domain.Message{}, nil, nil
}
end := start + limit
if end > len(all) {
end = len(all)
}
page := all[start:end]
var next *string
if end < len(all) {
last := page[len(page)-1]
c := encodeCursor(scope, last.CreatedAt, last.ID)
next = &c
}
return page, next, nil
}
@@ -0,0 +1,34 @@
package memory
import (
"sync"
"high-loud-apps-labs/internal/domain"
)
type Storage struct {
mu sync.RWMutex
users map[string]*domain.User
chats map[string]*domain.Chat
messages map[string][]domain.Message
}
func New() *Storage {
return &Storage{
users: make(map[string]*domain.User),
chats: make(map[string]*domain.Chat),
messages: make(map[string][]domain.Message),
}
}
func (s *Storage) Users() *UserRepo { return &UserRepo{s} }
func (s *Storage) Chats() *ChatRepo { return &ChatRepo{s} }
func (s *Storage) Messages() *MessageRepo { return &MessageRepo{s} }
type UserRepo struct{ *Storage }
type ChatRepo struct{ *Storage }
type MessageRepo struct{ *Storage }
var _ domain.UserRepository = (*UserRepo)(nil)
var _ domain.ChatRepository = (*ChatRepo)(nil)
var _ domain.MessageRepository = (*MessageRepo)(nil)
+59
View File
@@ -0,0 +1,59 @@
package memory
import (
"context"
"high-loud-apps-labs/internal/domain"
)
func (r *UserRepo) Create(ctx context.Context, user *domain.User) error {
if err := ctx.Err(); err != nil {
return err
}
r.mu.Lock()
defer r.mu.Unlock()
for _, u := range r.users {
if u.Username == user.Username {
return &domain.AlreadyExistsError{
Entity: "user",
Field: "username",
Value: user.Username,
}
}
}
stored := *user
r.users[user.ID] = &stored
return nil
}
func (r *UserRepo) GetByID(ctx context.Context, id string) (*domain.User, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
u, ok := r.users[id]
if !ok {
return nil, &domain.NotFoundError{Entity: "user", ID: id}
}
copy := *u
return &copy, nil
}
func (r *UserRepo) GetByUsername(ctx context.Context, username string) (*domain.User, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
r.mu.RLock()
defer r.mu.RUnlock()
for _, u := range r.users {
if u.Username == username {
copy := *u
return &copy, nil
}
}
return nil, &domain.NotFoundError{Entity: "user", ID: username}
}
+195
View File
@@ -0,0 +1,195 @@
package postgres
import (
"context"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type ChatRepo struct {
pool *pgxpool.Pool
}
func NewChatRepo(pool *pgxpool.Pool) *ChatRepo {
return &ChatRepo{pool: pool}
}
// Create атомарно создаёт чат и его участников.
func (r *ChatRepo) Create(ctx context.Context, chat *domain.Chat) error {
tx, err := r.pool.Begin(ctx)
if err != nil {
return mapError(err)
}
defer func() { _ = tx.Rollback(ctx) }()
const qChat = `INSERT INTO chats (id, title, created_at) VALUES ($1::uuid, $2, $3)`
if _, err := tx.Exec(ctx, qChat, chat.ID, chat.Title, chat.CreatedAt); err != nil {
if checkViolation(err) {
return &domain.ValidationError{Field: "chat", Message: "нарушено ограничение целостности"}
}
return mapError(err)
}
const qMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1::uuid, $2::uuid)`
for _, uid := range chat.MemberIDs {
if _, err := tx.Exec(ctx, qMember, chat.ID, uid); err != nil {
if foreignKeyViolation(err) {
return &domain.ValidationError{
Field: "member_ids",
Message: "неизвестный участник " + uid,
}
}
if uniqueViolation(err) {
return &domain.ValidationError{
Field: "member_ids",
Message: "дубликаты запрещены",
}
}
return mapError(err)
}
}
return mapError(tx.Commit(ctx))
}
func (r *ChatRepo) GetByID(ctx context.Context, id string) (*domain.Chat, error) {
const q = `SELECT id, title, created_at FROM chats WHERE id = $1::uuid`
c := &domain.Chat{}
err := r.pool.QueryRow(ctx, q, id).Scan(&c.ID, &c.Title, &c.CreatedAt)
if err != nil {
return nil, notFound(err, "chat", id)
}
members, err := r.loadMembers(ctx, []string{c.ID})
if err != nil {
return nil, err
}
c.MemberIDs = members[c.ID]
if c.MemberIDs == nil {
c.MemberIDs = []string{}
}
return c, nil
}
func (r *ChatRepo) ListByMember(ctx context.Context, userID string, limit int, cursor *string) ([]domain.Chat, *string, error) {
scope := "chats:" + userID
var (
afterTime time.Time
afterID string
hasCursor bool
)
if cursor != nil {
t, id, err := decodeCursor(*cursor, scope)
if err != nil {
return nil, nil, err
}
afterTime = t
afterID = id
hasCursor = true
}
var (
rows pgx.Rows
err error
)
if hasCursor {
const q = `
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = $1::uuid
AND (c.created_at, c.id) > ($2, $3::uuid)
ORDER BY c.created_at, c.id
LIMIT $4
`
rows, err = r.pool.Query(ctx, q, userID, afterTime, afterID, limit+1)
} else {
const q = `
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = $1::uuid
ORDER BY c.created_at, c.id
LIMIT $2
`
rows, err = r.pool.Query(ctx, q, userID, limit+1)
}
if err != nil {
return nil, nil, mapError(err)
}
defer rows.Close()
page := make([]domain.Chat, 0, limit)
for rows.Next() {
var c domain.Chat
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
return nil, nil, mapError(err)
}
page = append(page, c)
}
if err := rows.Err(); err != nil {
return nil, nil, mapError(err)
}
var next *string
if len(page) > limit {
page = page[:limit]
last := page[len(page)-1]
c := encodeCursor(scope, last.CreatedAt, last.ID)
next = &c
}
if len(page) > 0 {
ids := make([]string, len(page))
for i := range page {
ids[i] = page[i].ID
}
members, err := r.loadMembers(ctx, ids)
if err != nil {
return nil, nil, err
}
for i := range page {
if m, ok := members[page[i].ID]; ok {
page[i].MemberIDs = m
} else {
page[i].MemberIDs = []string{}
}
}
}
return page, next, nil
}
// loadMembers одним запросом собирает участников для указанных чатов.
func (r *ChatRepo) loadMembers(ctx context.Context, chatIDs []string) (map[string][]string, error) {
if len(chatIDs) == 0 {
return map[string][]string{}, nil
}
const q = `
SELECT chat_id, user_id
FROM chat_members
WHERE chat_id = ANY($1::uuid[])
ORDER BY chat_id, user_id
`
rows, err := r.pool.Query(ctx, q, chatIDs)
if err != nil {
return nil, mapError(err)
}
defer rows.Close()
result := make(map[string][]string, len(chatIDs))
for rows.Next() {
var chatID, userID string
if err := rows.Scan(&chatID, &userID); err != nil {
return nil, mapError(err)
}
result[chatID] = append(result[chatID], userID)
}
return result, mapError(rows.Err())
}
var _ domain.ChatRepository = (*ChatRepo)(nil)
@@ -0,0 +1,41 @@
package postgres
import (
"encoding/base64"
"strings"
"time"
"high-loud-apps-labs/internal/domain"
)
// Взял за основу что в inmemery делал
func encodeCursor(scope string, createdAt time.Time, id string) string {
raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id
return base64.RawURLEncoding.EncodeToString([]byte(raw))
}
func decodeCursor(cursor, expectedScope string) (time.Time, string, error) {
data, err := base64.RawURLEncoding.DecodeString(cursor)
if err != nil {
return time.Time{}, "", badCursor()
}
parts := strings.SplitN(string(data), "|", 3)
if len(parts) != 3 {
return time.Time{}, "", badCursor()
}
if parts[0] != expectedScope {
return time.Time{}, "", badCursor()
}
t, err := time.Parse(time.RFC3339Nano, parts[1])
if err != nil {
return time.Time{}, "", badCursor()
}
return t, parts[2], nil
}
func badCursor() error {
return &domain.ValidationError{
Field: "cursor",
Message: "некорректный формат",
}
}
+75
View File
@@ -0,0 +1,75 @@
package postgres
import (
"context"
"fmt"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/jackc/pgx/v5/stdlib"
"github.com/pressly/goose/v3"
"high-loud-apps-labs/migrations"
)
type Config struct {
URL string
MaxConns int32
MinConns int32
MaxConnLifetime time.Duration
MaxConnIdleTime time.Duration
ConnectTimeout time.Duration
}
func Connect(ctx context.Context, cfg Config) (*pgxpool.Pool, error) {
if cfg.URL == "" {
return nil, fmt.Errorf("DATABASE_URL пустой")
}
poolCfg, err := pgxpool.ParseConfig(cfg.URL)
if err != nil {
return nil, fmt.Errorf("разбор DATABASE_URL: %w", err)
}
if cfg.MaxConns > 0 {
poolCfg.MaxConns = cfg.MaxConns
}
if cfg.MinConns > 0 {
poolCfg.MinConns = cfg.MinConns
}
if cfg.MaxConnLifetime > 0 {
poolCfg.MaxConnLifetime = cfg.MaxConnLifetime
}
if cfg.MaxConnIdleTime > 0 {
poolCfg.MaxConnIdleTime = cfg.MaxConnIdleTime
}
if cfg.ConnectTimeout > 0 {
poolCfg.ConnConfig.ConnectTimeout = cfg.ConnectTimeout
}
poolCfg.HealthCheckPeriod = 10 * time.Second
pool, err := pgxpool.NewWithConfig(ctx, poolCfg)
if err != nil {
return nil, fmt.Errorf("создание пула: %w", err)
}
pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, fmt.Errorf("ping БД: %w", err)
}
return pool, nil
}
func RunMigrations(ctx context.Context, pool *pgxpool.Pool) error {
db := stdlib.OpenDBFromPool(pool)
goose.SetBaseFS(migrations.FS)
if err := goose.SetDialect("postgres"); err != nil {
return fmt.Errorf("goose dialect: %w", err)
}
if err := goose.UpContext(ctx, db, "."); err != nil {
return fmt.Errorf("применение миграций: %w", err)
}
return nil
}
@@ -0,0 +1,71 @@
package postgres
import (
"context"
"errors"
"github.com/jackc/pgerrcode"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"high-loud-apps-labs/internal/domain"
)
type coded interface {
Code() domain.ErrorCode
}
// mapError переводит ошибки драйвера в доменные.
func mapError(err error) error {
if err == nil {
return nil
}
var c coded
if errors.As(err, &c) {
return err
}
if errors.Is(err, pgx.ErrNoRows) {
return err
}
if errors.Is(err, context.DeadlineExceeded) {
return &domain.UnavailableError{Reason: "превышено время ожидания БД"}
}
if errors.Is(err, context.Canceled) {
return &domain.UnavailableError{Reason: "запрос отменён"}
}
return &domain.UnavailableError{Reason: err.Error()}
}
func notFound(err error, entity, id string) error {
if err == nil {
return nil
}
if errors.Is(err, pgx.ErrNoRows) {
return &domain.NotFoundError{Entity: entity, ID: id}
}
return mapError(err)
}
func uniqueViolation(err error) bool {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
return pgErr.Code == pgerrcode.UniqueViolation
}
return false
}
func foreignKeyViolation(err error) bool {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
return pgErr.Code == pgerrcode.ForeignKeyViolation
}
return false
}
func checkViolation(err error) bool {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
return pgErr.Code == pgerrcode.CheckViolation
}
return false
}
@@ -0,0 +1,108 @@
package postgres
import (
"context"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type MessageRepo struct {
pool *pgxpool.Pool
}
func NewMessageRepo(pool *pgxpool.Pool) *MessageRepo {
return &MessageRepo{pool: pool}
}
func (r *MessageRepo) Create(ctx context.Context, m *domain.Message) error {
const q = `
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1::uuid, $2::uuid, $3::uuid, $4, $5)
`
_, err := r.pool.Exec(ctx, q, m.ID, m.ChatID, m.SenderID, m.Text, m.CreatedAt)
if err != nil {
if foreignKeyViolation(err) {
return &domain.NotFoundError{Entity: "chat", ID: m.ChatID}
}
if checkViolation(err) {
return &domain.ValidationError{Field: "text", Message: "нарушено ограничение"}
}
return err
}
return nil
}
func (r *MessageRepo) ListByChat(ctx context.Context, chatID string, limit int, cursor *string) ([]domain.Message, *string, error) {
scope := "messages:" + chatID
var (
afterTime time.Time
afterID string
hasCursor bool
)
if cursor != nil {
t, id, err := decodeCursor(*cursor, scope)
if err != nil {
return nil, nil, err
}
afterTime = t
afterID = id
hasCursor = true
}
var (
rows pgx.Rows
err error
)
if hasCursor {
const q = `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1::uuid
AND (created_at, id) > ($2, $3::uuid)
ORDER BY created_at, id
LIMIT $4
`
rows, err = r.pool.Query(ctx, q, chatID, afterTime, afterID, limit+1)
} else {
const q = `
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1::uuid
ORDER BY created_at, id
LIMIT $2
`
rows, err = r.pool.Query(ctx, q, chatID, limit+1)
}
if err != nil {
return nil, nil, err
}
defer rows.Close()
page := make([]domain.Message, 0, limit)
for rows.Next() {
var m domain.Message
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
return nil, nil, err
}
page = append(page, m)
}
if err := rows.Err(); err != nil {
return nil, nil, err
}
var next *string
if len(page) > limit {
page = page[:limit]
last := page[len(page)-1]
c := encodeCursor(scope, last.CreatedAt, last.ID)
next = &c
}
return page, next, nil
}
var _ domain.MessageRepository = (*MessageRepo)(nil)
@@ -0,0 +1,59 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type SessionRepo struct {
pool *pgxpool.Pool
}
func NewSessionRepo(pool *pgxpool.Pool) *SessionRepo {
return &SessionRepo{pool: pool}
}
func (r *SessionRepo) Create(ctx context.Context, s *domain.Session) error {
const q = `
INSERT INTO sessions (token_hash, user_id, expires_at, created_at)
VALUES ($1, $2::uuid, $3, $4)
`
_, err := r.pool.Exec(ctx, q, s.TokenHash, s.UserID, s.ExpiresAt, s.CreatedAt)
if err != nil {
if uniqueViolation(err) {
return &domain.AlreadyExistsError{
Entity: "session",
Field: "token_hash",
Value: "",
}
}
return mapError(err)
}
return nil
}
func (r *SessionRepo) GetByTokenHash(ctx context.Context, tokenHash []byte) (*domain.Session, error) {
const q = `
SELECT token_hash, user_id, expires_at, created_at
FROM sessions
WHERE token_hash = $1
`
s := &domain.Session{}
err := r.pool.QueryRow(ctx, q, tokenHash).
Scan(&s.TokenHash, &s.UserID, &s.ExpiresAt, &s.CreatedAt)
if err != nil {
return nil, notFound(err, "session", "")
}
return s, nil
}
func (r *SessionRepo) DeleteByTokenHash(ctx context.Context, tokenHash []byte) error {
const q = `DELETE FROM sessions WHERE token_hash = $1`
_, err := r.pool.Exec(ctx, q, tokenHash)
return mapError(err)
}
var _ domain.SessionRepository = (*SessionRepo)(nil)
@@ -0,0 +1,18 @@
package postgres
import "github.com/jackc/pgx/v5/pgxpool"
type Storage struct {
pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool) *Storage {
return &Storage{pool: pool}
}
func (s *Storage) Pool() *pgxpool.Pool { return s.pool }
func (s *Storage) Users() *UserRepo { return &UserRepo{pool: s.pool} }
func (s *Storage) Chats() *ChatRepo { return &ChatRepo{pool: s.pool} }
func (s *Storage) Messages() *MessageRepo { return &MessageRepo{pool: s.pool} }
func (s *Storage) Sessions() *SessionRepo { return &SessionRepo{pool: s.pool} }
+76
View File
@@ -0,0 +1,76 @@
package postgres
import (
"context"
"github.com/jackc/pgx/v5/pgxpool"
"high-loud-apps-labs/internal/domain"
)
type UserRepo struct {
pool *pgxpool.Pool
}
func NewUserRepo(pool *pgxpool.Pool) *UserRepo {
return &UserRepo{pool: pool}
}
func (r *UserRepo) Create(ctx context.Context, user *domain.User) error {
const q = `
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1::uuid, $2, $3, $4, $5)
`
_, err := r.pool.Exec(ctx, q,
user.ID, user.Username, user.DisplayName, user.PasswordHash, user.CreatedAt,
)
if err != nil {
if uniqueViolation(err) {
return &domain.AlreadyExistsError{
Entity: "user",
Field: "username",
Value: user.Username,
}
}
if checkViolation(err) {
return &domain.ValidationError{
Field: "user",
Message: "нарушено ограничение целостности",
}
}
return mapError(err)
}
return nil
}
func (r *UserRepo) GetByID(ctx context.Context, id string) (*domain.User, error) {
const q = `
SELECT id, username, display_name, password_hash, created_at
FROM users
WHERE id = $1::uuid
`
u := &domain.User{}
err := r.pool.QueryRow(ctx, q, id).
Scan(&u.ID, &u.Username, &u.DisplayName, &u.PasswordHash, &u.CreatedAt)
if err != nil {
return nil, notFound(err, "user", id)
}
return u, nil
}
func (r *UserRepo) GetByUsername(ctx context.Context, username string) (*domain.User, error) {
const q = `
SELECT id, username, display_name, password_hash, created_at
FROM users
WHERE username = $1
`
u := &domain.User{}
err := r.pool.QueryRow(ctx, q, username).
Scan(&u.ID, &u.Username, &u.DisplayName, &u.PasswordHash, &u.CreatedAt)
if err != nil {
return nil, notFound(err, "user", username)
}
return u, nil
}
var _ domain.UserRepository = (*UserRepo)(nil)
+33
View File
@@ -0,0 +1,33 @@
package redis
import (
"context"
"fmt"
"time"
"github.com/redis/go-redis/v9"
)
func NewClient(url string) (*redis.Client, error) {
opt, err := redis.ParseURL(url)
if err != nil {
return nil, fmt.Errorf("разбор URL: %w", err)
}
opt.DialTimeout = 700 * time.Millisecond
opt.ReadTimeout = 700 * time.Millisecond
opt.WriteTimeout = 700 * time.Millisecond
opt.MaxRetries = 1
opt.PoolSize = 10
opt.ConnMaxIdleTime = time.Minute
client := redis.NewClient(opt)
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
if err := client.Ping(ctx).Err(); err != nil {
_ = client.Close()
return nil, fmt.Errorf("ping: %w", err)
}
return client, nil
}
+31
View File
@@ -0,0 +1,31 @@
package redis
import (
"context"
"errors"
"high-loud-apps-labs/internal/domain"
)
type coded interface {
Code() domain.ErrorCode
}
// mapError переводит ошибки драйвера в доменные.
// Любая недоступность redis (dial/read/write/context) → UnavailableError (503).
func mapError(err error) error {
if err == nil {
return nil
}
var c coded
if errors.As(err, &c) {
return err
}
if errors.Is(err, context.DeadlineExceeded) {
return &domain.UnavailableError{Reason: "превышено время ожидания redis"}
}
if errors.Is(err, context.Canceled) {
return &domain.UnavailableError{Reason: "запрос отменён"}
}
return &domain.UnavailableError{Reason: err.Error()}
}
+80
View File
@@ -0,0 +1,80 @@
package redis
import (
"context"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"time"
"github.com/redis/go-redis/v9"
"high-loud-apps-labs/internal/domain"
)
const sessionKeyPrefix = "session:"
type SessionRepo struct {
client *redis.Client
}
func NewSessionRepo(client *redis.Client) *SessionRepo {
return &SessionRepo{client: client}
}
type sessionValue struct {
UserID string `json:"user_id"`
ExpiresAt time.Time `json:"expires_at"`
CreatedAt time.Time `json:"created_at"`
}
func (r *SessionRepo) key(tokenHash []byte) string {
return sessionKeyPrefix + hex.EncodeToString(tokenHash)
}
func (r *SessionRepo) Create(ctx context.Context, s *domain.Session) error {
ttl := time.Until(s.ExpiresAt)
if ttl <= 0 {
return nil
}
data, err := json.Marshal(sessionValue{
UserID: s.UserID,
ExpiresAt: s.ExpiresAt.UTC(),
CreatedAt: s.CreatedAt.UTC(),
})
if err != nil {
return fmt.Errorf("сериализация сессии: %w", err)
}
return mapError(r.client.Set(ctx, r.key(s.TokenHash), data, ttl).Err())
}
func (r *SessionRepo) GetByTokenHash(ctx context.Context, tokenHash []byte) (*domain.Session, error) {
data, err := r.client.Get(ctx, r.key(tokenHash)).Bytes()
if err != nil {
if errors.Is(err, redis.Nil) {
return nil, &domain.NotFoundError{Entity: "session"}
}
return nil, mapError(err)
}
var sv sessionValue
if err := json.Unmarshal(data, &sv); err != nil {
return nil, fmt.Errorf("разбор сессии: %w", err)
}
return &domain.Session{
TokenHash: tokenHash,
UserID: sv.UserID,
ExpiresAt: sv.ExpiresAt,
CreatedAt: sv.CreatedAt,
}, nil
}
func (r *SessionRepo) DeleteByTokenHash(ctx context.Context, tokenHash []byte) error {
return mapError(r.client.Del(ctx, r.key(tokenHash)).Err())
}
var _ domain.SessionRepository = (*SessionRepo)(nil)
+67
View File
@@ -0,0 +1,67 @@
-- +goose Up
-- +goose StatementBegin
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT users_username_format
CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_not_blank
CHECK (display_name !~ '^[[:space:]]*$'),
CONSTRAINT users_display_name_len
CHECK (char_length(display_name) <= 100),
CONSTRAINT users_password_hash_not_blank
CHECK (length(password_hash) > 0)
);
CREATE UNIQUE INDEX users_username_uniq ON users (username);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT chats_title_not_blank CHECK (title !~ '^[[:space:]]*$'),
CONSTRAINT chats_title_len CHECK (char_length(title) <= 100)
);
CREATE INDEX chats_created_id_idx ON chats (created_at, id);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
joined_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT messages_text_not_blank CHECK (text !~ '^[[:space:]]*$'),
CONSTRAINT messages_text_len CHECK (char_length(text) <= 4000)
);
CREATE INDEX messages_chat_created_id_idx
ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash BYTEA PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32)
);
CREATE INDEX sessions_user_idx ON sessions (user_id);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP TABLE IF EXISTS sessions;
DROP TABLE IF EXISTS messages;
DROP TABLE IF EXISTS chat_members;
DROP TABLE IF EXISTS chats;
DROP TABLE IF EXISTS users;
-- +goose StatementEnd
+6
View File
@@ -0,0 +1,6 @@
package migrations
import "embed"
//go:embed *.sql
var FS embed.FS
+92
View File
@@ -0,0 +1,92 @@
name: mtusi-messenger-lab2
services:
postgres:
image: postgres:16.4-alpine
restart: unless-stopped
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_DB: messenger
secrets:
- postgres_password
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
networks:
- internal
redis:
image: redis:7.4-alpine
restart: unless-stopped
command:
- redis-server
- --appendonly
- "yes"
- --appendfsync
- everysec
- --save
- "60 1000"
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
networks:
- internal
api:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger-api:lab2
restart: unless-stopped
ports:
- "8080:8080"
environment:
APP_HOST: "0.0.0.0"
APP_PORT: "8080"
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
SESSION_STORE: "redis"
SESSION_TTL_SECONDS: "3600"
secrets:
- database_url
- cache_url
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD-SHELL", "wget -q -O - http://127.0.0.1:8080/health/ready >/dev/null || exit 1"]
interval: 10s
timeout: 3s
retries: 5
start_period: 15s
networks:
- internal
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
volumes:
postgres_data:
redis_data:
networks:
internal:
driver: bridge
+38
View File
@@ -0,0 +1,38 @@
# Backup → Restore → сверка
# date: 2026-10-02T16:46:16Z
## Снимок источника
users=52
chats=37
messages=110222
sessions=0
md5 первых 1000 сообщений: f3c9c53ed0fd56da19a01f213d0ff2f0
## pg_dump -Fc
файл: /mnt/c/Users/Антон/Desktop/4_курс/mtusi2026lab2-fork/evidence/dump_20261002_194616.dump
размер: 3.4M
время дампа: 1s
## Поднимаем целевой контейнер pg_restore_target на :5433
Ждём готовности...
## pg_restore
время восстановления: 0s
## Снимок цели
users=52
chats=37
messages=110222
sessions=0
md5 первых 1000 сообщений: f3c9c53ed0fd56da19a01f213d0ff2f0
## Сверка
PASS: счётчики совпадают
PASS: контрольные суммы совпадают
## Индексы в восстановленной БД
indexname | size
------------------------------+---------
messages_chat_created_id_idx | 6360 kB
messages_pkey | 3424 kB
(2 rows)
+4
View File
@@ -0,0 +1,4 @@
hot=349f1aef-3bbc-42d1-8724-e8d22b8c2253
medium-1=532a232a-4038-4d2a-96dd-e5c901e868a2
small-1=950e3367-500a-43b3-b824-b5cf521839b9
tiny-1=c099542c-e3c2-49ff-ab10-5389ed2450af
+33
View File
@@ -0,0 +1,33 @@
# EXPLAIN (ANALYZE, BUFFERS) для истории сообщений
# date: 2026-10-02T11:28:14Z
# chat_id: 349f1aef-3bbc-42d1-8724-e8d22b8c2253
## Ключевой запрос пагинации
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..8.05 rows=50 width=69) (actual time=0.025..0.042 rows=50 loops=1)
Buffers: shared hit=45
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.42..8419.02 rows=55133 width=69) (actual time=0.024..0.038 rows=50 loops=1)
Index Cond: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid)
Buffers: shared hit=45
Planning:
Buffers: shared hit=109
Planning Time: 0.611 ms
Execution Time: 0.064 ms
(9 rows)
## Индексы таблицы messages
indexname | indexdef
------------------------------+----------------------------------------------------------------------------------------------------
messages_pkey | CREATE UNIQUE INDEX messages_pkey ON public.messages USING btree (id)
messages_chat_created_id_idx | CREATE INDEX messages_chat_created_id_idx ON public.messages USING btree (chat_id, created_at, id)
(2 rows)
## Оценка размера и количества
estimated_rows | total_size
----------------+------------
110222 | 25 MB
(1 row)
+33
View File
@@ -0,0 +1,33 @@
# EXPLAIN (ANALYZE, BUFFERS) для истории сообщений
# date: 2026-10-02T11:01:11Z
# chat_id: cf9e8ca9-d08c-41d1-b55f-18c9fba43aec
## Ключевой запрос пагинации
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..4.38 rows=50 width=73) (actual time=0.021..0.029 rows=50 loops=1)
Buffers: shared hit=3
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..819.43 rows=10000 width=73) (actual time=0.020..0.025 rows=50 loops=1)
Index Cond: (chat_id = 'cf9e8ca9-d08c-41d1-b55f-18c9fba43aec'::uuid)
Buffers: shared hit=3
Planning:
Buffers: shared hit=111
Planning Time: 0.694 ms
Execution Time: 0.063 ms
(9 rows)
## Индексы таблицы messages
indexname | indexdef
------------------------------+----------------------------------------------------------------------------------------------------
messages_pkey | CREATE UNIQUE INDEX messages_pkey ON public.messages USING btree (id)
messages_chat_created_id_idx | CREATE INDEX messages_chat_created_id_idx ON public.messages USING btree (chat_id, created_at, id)
(2 rows)
## Оценка размера и количества
estimated_rows | total_size
----------------+------------
10222 | 2264 kB
(1 row)
+81
View File
@@ -0,0 +1,81 @@
# Сравнение индексов: keyset-пагинация, chat_id=349f1aef-3bbc-42d1-8724-e8d22b8c2253
# date: 2026-10-02T16:45:25Z
## A. Baseline (chat_id, created_at, id)
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..7.31 rows=50 width=69) (actual time=0.029..0.046 rows=50 loops=1)
Buffers: shared hit=42 read=3
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.42..7619.95 rows=55273 width=69) (actual time=0.028..0.042 rows=50 loops=1)
Index Cond: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid)
Buffers: shared hit=42 read=3
Planning:
Buffers: shared hit=106 read=1
Planning Time: 0.664 ms
Execution Time: 0.070 ms
(9 rows)
## B1. Covering (chat_id, created_at, id) INCLUDE (sender_id)
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..7.77 rows=50 width=69) (actual time=0.027..0.048 rows=50 loops=1)
Buffers: shared hit=42 read=4
-> Index Scan using messages_covering_small on messages (cost=0.42..8096.41 rows=55056 width=69) (actual time=0.026..0.044 rows=50 loops=1)
Index Cond: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid)
Buffers: shared hit=42 read=4
Planning:
Buffers: shared hit=111 read=1
Planning Time: 0.639 ms
Execution Time: 0.070 ms
(9 rows)
## B2. Covering (chat_id, created_at, id) INCLUDE (sender_id, text)
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..4.40 rows=50 width=69) (actual time=0.038..0.044 rows=50 loops=1)
Buffers: shared hit=1 read=3
-> Index Only Scan using messages_covering_full on messages (cost=0.42..4393.54 rows=55144 width=69) (actual time=0.037..0.041 rows=50 loops=1)
Index Cond: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid)
Heap Fetches: 0
Buffers: shared hit=1 read=3
Planning:
Buffers: shared hit=112 read=1
Planning Time: 0.717 ms
Execution Time: 0.071 ms
(10 rows)
## C. Без индекса (Seq Scan)
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4314.02..4319.77 rows=50 width=69) (actual time=7.709..9.590 rows=50 loops=1)
Buffers: shared hit=1486
-> Gather Merge (cost=4314.02..7988.96 rows=31956 width=69) (actual time=7.707..9.585 rows=50 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=1486
-> Sort (cost=3314.01..3393.90 rows=31956 width=69) (actual time=5.760..5.763 rows=50 loops=2)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 32kB
Buffers: shared hit=1486
Worker 0: Sort Method: top-N heapsort Memory: 32kB
-> Parallel Seq Scan on messages (cost=0.00..2252.46 rows=31956 width=69) (actual time=0.009..3.673 rows=27500 loops=2)
Filter: (chat_id = '349f1aef-3bbc-42d1-8724-e8d22b8c2253'::uuid)
Rows Removed by Filter: 27611
Buffers: shared hit=1442
Planning:
Buffers: shared hit=84
Planning Time: 0.598 ms
Execution Time: 9.660 ms
(19 rows)
## Восстанавливаем baseline
indexname | size
------------------------------+---------
messages_chat_created_id_idx | 6360 kB
messages_pkey | 4568 kB
(2 rows)
+31
View File
@@ -0,0 +1,31 @@
hot: 55000 сообщений за 61.7s (891/s)
medium-1: 10000 сообщений за 11.4s (879/s)
medium-2: 10000 сообщений за 11.4s (879/s)
medium-3: 10000 сообщений за 11.7s (854/s)
small-1: 1000 сообщений за 1.3s (781/s)
small-2: 1000 сообщений за 1.2s (800/s)
small-3: 1000 сообщений за 1.2s (820/s)
small-4: 1000 сообщений за 1.3s (790/s)
small-5: 1000 сообщений за 1.2s (810/s)
small-6: 1000 сообщений за 1.2s (820/s)
small-7: 1000 сообщений за 1.3s (791/s)
small-8: 1000 сообщений за 1.2s (810/s)
small-9: 1000 сообщений за 1.2s (820/s)
small-10: 1000 сообщений за 1.2s (810/s)
tiny-1: 500 сообщений за 0.7s (761/s)
tiny-2: 500 сообщений за 0.7s (761/s)
tiny-3: 500 сообщений за 0.7s (762/s)
tiny-4: 500 сообщений за 0.6s (780/s)
tiny-5: 500 сообщений за 0.6s (800/s)
tiny-6: 500 сообщений за 0.7s (762/s)
tiny-7: 500 сообщений за 0.6s (781/s)
tiny-8: 500 сообщений за 0.7s (744/s)
tiny-9: 500 сообщений за 0.7s (728/s)
tiny-10: 500 сообщений за 0.7s (762/s)
Всего 100000 сообщений за 115.5s (866/s)
chat_id для EXPLAIN:
hot: 349f1aef-3bbc-42d1-8724-e8d22b8c2253
medium-1: 532a232a-4038-4d2a-96dd-e5c901e868a2
small-1: 950e3367-500a-43b3-b824-b5cf521839b9
tiny-1: c099542c-e3c2-49ff-ab10-5389ed2450af
+31
View File
@@ -0,0 +1,31 @@
# Стоимость записи: 5000 INSERT в один чат
# date: 2026-10-02T16:45:29Z
# chat_id: 349f1aef-3bbc-42d1-8724-e8d22b8c2253
## A. Baseline (chat_id, created_at, id)
## INSERT 5000 rows
Timing is on.
DO
Time: 353.267 ms
indexname | size
------------------------------+---------
messages_chat_created_id_idx | 6768 kB
messages_pkey | 4736 kB
(2 rows)
## B. Covering (chat_id, created_at, id) INCLUDE (sender_id)
## INSERT 5000 rows
Timing is on.
DO
Time: 288.259 ms
indexname | size
-------------------------+---------
messages_covering_small | 8848 kB
messages_pkey | 4944 kB
(2 rows)
## Восстанавливаем baseline
+5
View File
@@ -0,0 +1,5 @@
@echo off
setlocal
set SCRIPT_DIR=%~dp0
bash "%SCRIPT_DIR%restart.sh"
exit /b %ERRORLEVEL%
+45
View File
@@ -0,0 +1,45 @@
#!/bin/sh
set -eu
# Перезапускает API и все используемые хранилища, сохраняя volumes и данные.
# Не удаляет volumes, не пересоздаёт схему, не сидит данные заново.
cd "$(dirname "$0")/.."
COMPOSE="docker compose"
if ! $COMPOSE version >/dev/null 2>&1; then
COMPOSE="docker-compose"
fi
if [ ! -f .env ]; then
: > .env
fi
echo "[restart] останавливаем api, postgres, redis" >&2
$COMPOSE --env-file .env stop api postgres redis
echo "[restart] запускаем postgres" >&2
$COMPOSE --env-file .env start postgres
wait_healthy() {
service="$1"
i=0
until [ "$($COMPOSE ps -q "$service" | xargs -r docker inspect -f '{{.State.Health.Status}}' 2>/dev/null)" = "healthy" ]; do
i=$((i + 1))
if [ "$i" -gt 60 ]; then
echo "[restart] $service не стал healthy за 60 секунд" >&2
exit 1
fi
sleep 1
done
}
wait_healthy postgres
echo "[restart] запускаем redis" >&2
$COMPOSE --env-file .env start redis
wait_healthy redis
echo "[restart] запускаем api" >&2
$COMPOSE --env-file .env start api
echo "[restart] готово" >&2
exit 0
+58
View File
@@ -0,0 +1,58 @@
# Собственные тесты
Проверки негативных сценариев, конкурентной работы, жизненного цикла
сессий и отказов хранилищ. Отдельно от публичных `tests/`.
Сервер должен быть поднят на `http://localhost:8080`.
## Быстрый прогон
python student-tests/run_all.py --base-url http://localhost:8080
Запускает `test_cases.py`, `test_concurrency.py`, `test_auth.py`.
Это базовый набор, не требующий особой конфигурации стенда.
## Отдельные сценарии
python student-tests/test_expiry.py --base-url http://localhost:8080
Требует стенд с `SESSION_TTL_SECONDS=2`. Проверяет, что сессия
перестаёт работать после истечения TTL. Меняй TTL в `compose.yaml`,
перезапускай api и прогоняй.
python student-tests/test_resilience.py --service redis
python student-tests/test_resilience.py --service postgres
Требуют запущенного Docker и работающего стенда. Скрипт останавливает
указанный сервис через `docker compose stop`, проверяет, что защищённые
endpoint отдают 503 unavailable (не 401 и не 500), и запускает сервис
обратно.
## Данные для EXPLAIN
python student-tests/seed_messages.py --count 10000
student-tests/explain_history.sh <chat_id>
`seed_messages.py` печатает `chat_id`; передай его в `explain_history.sh`,
результат сохранится в `evidence/explain_history.txt`.
## Трек 2: план запроса и восстановление
Исследование на ≥100 000 сообщениях с неравномерными размерами чатов.
python student-tests/seed_large.py
# сохранить chat_id из вывода в evidence/chat_ids.txt
student-tests/explain_history.sh <hot_chat_id>
student-tests/compare_indexes.sh <hot_chat_id>
student-tests/write_bench.sh
student-tests/backup_restore.sh
Результаты попадают в `evidence/`:
- `explain_history.txt` — EXPLAIN (ANALYZE, BUFFERS) ключевого запроса
- `index_comparison.txt` — baseline vs covering vs Seq Scan
- `write_cost.txt` — время 5000 INSERT под разными индексами
- `backup_restore.txt` — pg_dump → pg_restore → сверка счётчиков и md5
Восстановленный контейнер `pg_restore_target` оставлен для ручной проверки
и удаляется вручную после эксперимента.
+115
View File
@@ -0,0 +1,115 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
mkdir -p evidence
COMPOSE="docker compose"
if ! $COMPOSE version >/dev/null 2>&1; then
COMPOSE="docker-compose"
fi
RESTORE_CONTAINER=pg_restore_target
RESTORE_PORT=5433
RESTORE_VOLUME=mtusi_restore_test
DUMP_FILE="$(pwd)/evidence/dump_$(date +%Y%m%d_%H%M%S).dump"
docker rm -f "$RESTORE_CONTAINER" >/dev/null 2>&1 || true
{
echo "# Backup → Restore → сверка"
echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
echo
echo "## Снимок источника"
SRC_COUNTS=$($COMPOSE --env-file .env exec -T postgres \
psql -U messenger -d messenger -t -A -c "
SELECT 'users=' || count(*) FROM users
UNION ALL SELECT 'chats=' || count(*) FROM chats
UNION ALL SELECT 'messages=' || count(*) FROM messages
UNION ALL SELECT 'sessions=' || count(*) FROM sessions;")
echo "$SRC_COUNTS"
SRC_SAMPLE=$($COMPOSE --env-file .env exec -T postgres \
psql -U messenger -d messenger -t -A -c "
SELECT md5(string_agg(id::text || '|' || text || '|' || created_at::text,
E'\n' ORDER BY id))
FROM (SELECT id, text, created_at FROM messages ORDER BY id LIMIT 1000) s;")
echo "md5 первых 1000 сообщений: $SRC_SAMPLE"
echo
echo "## pg_dump -Fc"
START=$(date +%s)
$COMPOSE --env-file .env exec -T postgres \
pg_dump -U messenger -Fc -d messenger > "$DUMP_FILE"
END=$(date +%s)
echo "файл: $DUMP_FILE"
echo "размер: $(du -h "$DUMP_FILE" | cut -f1)"
echo "время дампа: $((END - START))s"
echo
echo "## Поднимаем целевой контейнер $RESTORE_CONTAINER на :$RESTORE_PORT"
docker volume create "$RESTORE_VOLUME" >/dev/null
docker run -d --name "$RESTORE_CONTAINER" \
-e POSTGRES_PASSWORD=restore-only \
-e POSTGRES_USER=messenger \
-e POSTGRES_DB=messenger \
-p "$RESTORE_PORT:5432" \
-v "$RESTORE_VOLUME:/var/lib/postgresql/data" \
postgres:16.4-alpine >/dev/null
echo "Ждём готовности..."
i=0
until docker exec "$RESTORE_CONTAINER" pg_isready -U messenger -d messenger >/dev/null 2>&1; do
i=$((i + 1))
if [ "$i" -gt 30 ]; then
echo "контейнер не поднялся за 30 секунд" >&2
exit 1
fi
sleep 1
done
echo "## pg_restore"
START=$(date +%s)
docker exec -i "$RESTORE_CONTAINER" \
pg_restore -U messenger -d messenger --no-owner --no-acl < "$DUMP_FILE"
END=$(date +%s)
echo "время восстановления: $((END - START))s"
echo
echo "## Снимок цели"
DST_COUNTS=$(docker exec "$RESTORE_CONTAINER" \
psql -U messenger -d messenger -t -A -c "
SELECT 'users=' || count(*) FROM users
UNION ALL SELECT 'chats=' || count(*) FROM chats
UNION ALL SELECT 'messages=' || count(*) FROM messages
UNION ALL SELECT 'sessions=' || count(*) FROM sessions;")
echo "$DST_COUNTS"
DST_SAMPLE=$(docker exec "$RESTORE_CONTAINER" \
psql -U messenger -d messenger -t -A -c "
SELECT md5(string_agg(id::text || '|' || text || '|' || created_at::text,
E'\n' ORDER BY id))
FROM (SELECT id, text, created_at FROM messages ORDER BY id LIMIT 1000) s;")
echo "md5 первых 1000 сообщений: $DST_SAMPLE"
echo
echo "## Сверка"
[ "$SRC_COUNTS" = "$DST_COUNTS" ] && echo "PASS: счётчики совпадают" \
|| echo "FAIL: счётчики различаются"
[ "$SRC_SAMPLE" = "$DST_SAMPLE" ] && echo "PASS: контрольные суммы совпадают" \
|| echo "FAIL: контрольные суммы различаются"
echo
echo "## Индексы в восстановленной БД"
docker exec "$RESTORE_CONTAINER" \
psql -U messenger -d messenger -c "
SELECT indexname, pg_size_pretty(pg_relation_size(indexname::regclass)) AS size
FROM pg_indexes WHERE tablename='messages' ORDER BY indexname;"
} | tee evidence/backup_restore.txt
echo
echo "Восстановленный контейнер оставлен для ручной проверки:"
echo " docker exec -it $RESTORE_CONTAINER psql -U messenger -d messenger"
echo "Удалить после проверки:"
echo " docker rm -f $RESTORE_CONTAINER && docker volume rm $RESTORE_VOLUME"
+66
View File
@@ -0,0 +1,66 @@
#!/bin/sh
set -eu
chat_id="${1:-}"
if [ -z "$chat_id" ]; then
echo "usage: $0 <chat_id>" >&2
echo "chat_id печатает student-tests/seed_large.py" >&2
exit 2
fi
cd "$(dirname "$0")/.."
mkdir -p evidence
COMPOSE="docker compose"
if ! $COMPOSE version >/dev/null 2>&1; then
COMPOSE="docker-compose"
fi
psql() {
$COMPOSE --env-file .env exec -T postgres \
psql -U messenger -d messenger -v ON_ERROR_STOP=1 "$@"
}
QUERY="EXPLAIN (ANALYZE, BUFFERS) SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '$chat_id'::uuid ORDER BY created_at, id LIMIT 50;"
reset_indexes() {
psql -c "DROP INDEX IF EXISTS messages_covering_small;
DROP INDEX IF EXISTS messages_covering_full;
DROP INDEX IF EXISTS messages_chat_created_id_idx;" >/dev/null
}
{
echo "# Сравнение индексов: keyset-пагинация, chat_id=$chat_id"
echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
echo
echo "## A. Baseline (chat_id, created_at, id)"
reset_indexes
psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); ANALYZE messages;" >/dev/null
psql -c "$QUERY"
echo
echo "## B1. Covering (chat_id, created_at, id) INCLUDE (sender_id)"
reset_indexes
psql -c "CREATE INDEX messages_covering_small ON messages (chat_id, created_at, id) INCLUDE (sender_id); ANALYZE messages;" >/dev/null
psql -c "$QUERY"
echo
echo "## B2. Covering (chat_id, created_at, id) INCLUDE (sender_id, text)"
reset_indexes
psql -c "CREATE INDEX messages_covering_full ON messages (chat_id, created_at, id) INCLUDE (sender_id, text); ANALYZE messages;" >/dev/null
psql -c "$QUERY"
echo
echo "## C. Без индекса (Seq Scan)"
reset_indexes
psql -c "ANALYZE messages;" >/dev/null
psql -c "$QUERY"
echo
echo "## Восстанавливаем baseline"
reset_indexes
psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); ANALYZE messages;" >/dev/null
psql -c "SELECT indexname, pg_size_pretty(pg_relation_size(indexname::regclass)) AS size
FROM pg_indexes WHERE tablename='messages' ORDER BY indexname;"
} | tee evidence/index_comparison.txt
+44
View File
@@ -0,0 +1,44 @@
#!/bin/sh
set -eu
chat_id="${1:-}"
if [ -z "$chat_id" ]; then
echo "usage: $0 <chat_id>" >&2
echo "chat_id печатает student-tests/seed_messages.py" >&2
exit 2
fi
cd "$(dirname "$0")/.."
mkdir -p evidence
{
echo "# EXPLAIN (ANALYZE, BUFFERS) для истории сообщений"
echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
echo "# chat_id: $chat_id"
echo
echo "## Ключевой запрос пагинации"
docker compose exec -T postgres psql -U messenger -d messenger -c "
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '$chat_id'
ORDER BY created_at, id
LIMIT 50;
"
echo
echo "## Индексы таблицы messages"
docker compose exec -T postgres psql -U messenger -d messenger -c "
SELECT indexname, indexdef FROM pg_indexes
WHERE tablename = 'messages';
"
echo
echo "## Оценка размера и количества"
docker compose exec -T postgres psql -U messenger -d messenger -c "
SELECT reltuples::bigint AS estimated_rows,
pg_size_pretty(pg_total_relation_size('messages')) AS total_size
FROM pg_class WHERE relname = 'messages';
"
} | tee evidence/explain_history.txt
+26
View File
@@ -0,0 +1,26 @@
#!/usr/bin/env python3
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent
QUICK = ('test_cases.py', 'test_concurrency.py', 'test_auth.py')
def main():
args = sys.argv[1:]
failed = []
for script in QUICK:
print(f'=== {script} ===')
result = subprocess.run([sys.executable, str(ROOT / script), *args])
if result.returncode != 0:
failed.append(script)
if failed:
print('FAILED:', ', '.join(failed))
sys.exit(1)
print('=== Все тесты прошли ===')
if __name__ == '__main__':
main()
+82
View File
@@ -0,0 +1,82 @@
#!/usr/bin/env python3
"""Сидирует 100k сообщений в 24 чата с неравномерными размерами (трек 2)."""
import base64
import sys
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, arguments, check, run # noqa: E402
def make_user(c, label):
username = f'{label}_{uuid.uuid4().hex[:12]}'
password = 'T3st-' + uuid.uuid4().hex
user = c.call('POST', '/api/v1/users', 201, body={
'username': username, 'display_name': label.capitalize(),
'password': password}, schema='User')['json']
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
s = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')['json']
return {'id': user['id'], 'username': username, 'token': s['token']}
def seed_chat(base_url, ca_file, alice, bob, title, count, workers=8):
c = Client(base_url, ca_file)
chat = c.call('POST', '/api/v1/chats', 201, actor=alice, body={
'title': title, 'member_ids': [alice['id'], bob['id']]},
schema='Chat')['json']
chat_id = chat['id']
per_worker = count // workers
remainder = count - per_worker * workers
def worker(wid):
local = Client(base_url, ca_file, timeout=20)
n = per_worker + (1 if wid < remainder else 0)
for i in range(n):
local.call('POST', f'/api/v1/chats/{chat_id}/messages', 201,
actor=alice, body={'text': f'{title} #{wid}-{i}'},
schema='Message')
started = time.monotonic()
with ThreadPoolExecutor(max_workers=workers) as pool:
list(pool.map(worker, range(workers)))
elapsed = time.monotonic() - started
print(f' {title}: {count} сообщений за {elapsed:.1f}s ({count/max(elapsed,0.001):.0f}/s)')
return chat_id
def main():
args = arguments('Сидирует неравномерные чаты для трека 2')
c = Client(args.base_url, args.ca_file)
alice = make_user(c, 'track2_a')
bob = make_user(c, 'track2_b')
plan = (
[('hot', 55_000)] +
[('medium-%d' % i, 10_000) for i in range(1, 4)] +
[('small-%d' % i, 1_000) for i in range(1, 11)] +
[('tiny-%d' % i, 500) for i in range(1, 11)]
)
total = sum(n for _, n in plan)
check(total == 100_000, f'сумма {total} != 100000')
result = {}
started = time.monotonic()
for title, count in plan:
result[title] = seed_chat(args.base_url, args.ca_file, alice, bob, title, count)
elapsed = time.monotonic() - started
print(f'\nВсего {total} сообщений за {elapsed:.1f}s ({total/elapsed:.0f}/s)')
print('chat_id для EXPLAIN (сохраните эти значения):')
for title in ('hot', 'medium-1', 'small-1', 'tiny-1'):
print(f' {title}: {result[title]}')
if __name__ == '__main__':
run(main)
+56
View File
@@ -0,0 +1,56 @@
#!/usr/bin/env python3
"""Заполняет один чат N сообщениями. Надо EXPLAIN."""
import base64
import sys
import time
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, arguments, check, run # noqa: E402
def make_user(c, label):
username = f'{label}_{uuid.uuid4().hex[:12]}'
password = 'T3st-' + uuid.uuid4().hex
user = c.call('POST', '/api/v1/users', 201, body={
'username': username, 'display_name': label.capitalize(),
'password': password}, schema='User')['json']
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
s = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')['json']
return {'id': user['id'], 'token': s['token']}
def main():
def configure(p):
p.add_argument('--count', type=int, default=10000)
args = arguments('Сид для EXPLAIN: создаёт count сообщений в новом чате', configure)
check(args.count >= 1 and args.count <= 1_000_000, 'count вне диапазона')
c = Client(args.base_url, args.ca_file)
alice = make_user(c, 'seed_a')
bob = make_user(c, 'seed_b')
chat = c.call('POST', '/api/v1/chats', 201, actor=alice, body={
'title': 'Seed chat', 'member_ids': [alice['id'], bob['id']]},
schema='Chat')['json']
started = time.monotonic()
for i in range(args.count):
c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 201,
actor=alice, body={'text': f'seed message {i}'}, schema='Message')
if (i + 1) % 1000 == 0:
print(f' {i + 1}/{args.count}')
elapsed = time.monotonic() - started
print(f'seeded {args.count} messages in {elapsed:.1f}s '
f'({args.count / elapsed:.0f}/s)')
print(f'chat_id={chat["id"]}')
if __name__ == '__main__':
run(main)
+81
View File
@@ -0,0 +1,81 @@
#!/usr/bin/env python3
import base64
import uuid
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, arguments, check, run # noqa: E402
def register(c, username, password):
c.call('POST', '/api/v1/users', 201, body={
'username': username,
'display_name': 'Auth test',
'password': password,
})
def login(c, username, password):
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
r = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')
return r['json']
def main():
args = arguments('Logout и неверные учётные данные')
c = Client(args.base_url, args.ca_file)
# --- logout отзывает текущую сессию ---
username = 'lo_' + uuid.uuid4().hex[:10]
password = 'T3st-' + uuid.uuid4().hex
register(c, username, password)
session = login(c, username, password)
actor = {'id': session['user']['id'], 'token': session['token']}
# токен работает
c.call('GET', '/api/v1/users/me', actor=actor, schema='User')
# отзываем
c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=actor)
# тот же токен больше не работает
c.call('GET', '/api/v1/users/me', 401, actor=actor)
c.call('DELETE', '/api/v1/auth/sessions/current', 401, actor=actor)
# --- неверный пароль и неизвестный username дают одинаковый 401 ---
wrong = base64.b64encode(f'{username}:wrong-password-123'.encode()).decode()
r_wrong = c.call('POST', '/api/v1/auth/sessions', 401,
headers={'Authorization': 'Basic ' + wrong})
check('Basic' in r_wrong['headers'].get('WWW-Authenticate', ''),
'нет WWW-Authenticate: Basic на неверный пароль')
unknown = base64.b64encode(
f'nobody_{uuid.uuid4().hex[:10]}:any-password-123'.encode()).decode()
r_unknown = c.call('POST', '/api/v1/auth/sessions', 401,
headers={'Authorization': 'Basic ' + unknown})
check(r_wrong['json']['error']['code'] == 'unauthorized',
'неверный пароль: ожидался код unauthorized')
check(r_unknown['json']['error']['code'] == 'unauthorized',
'неизвестный username: ожидался код unauthorized')
check(r_wrong['json']['error']['message'] == r_unknown['json']['error']['message'],
'сообщения отличаются: перебор username возможен')
# --- X-User-Id не даёт доступ в lab2 ---
c.call('GET', '/api/v1/users/me', 401,
headers={'X-User-Id': session['user']['id']})
# --- Basic на бизнес-endpoint не проходит ---
good = base64.b64encode(f'{username}:{password}'.encode()).decode()
c.call('GET', '/api/v1/users/me', 401,
headers={'Authorization': 'Basic ' + good})
print('PASS: logout, wrong password, X-User-Id и Basic на бизнес-endpoint')
if __name__ == '__main__':
run(main)
+112
View File
@@ -0,0 +1,112 @@
#!/usr/bin/env python3
import sys
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, LAB, Failure, arguments, check, run # noqa: E402
def main():
args = arguments('Собственные тесты негативных сценариев')
c = Client(args.base_url, args.ca_file)
alice, bob, eve, chat = c.bootstrap()
path = '/api/v1/chats/' + chat['id']
# --- некорректный JSON ---
malformed = b'{"username":"alice","display_name":"A"'
c.call('POST', '/api/v1/users', 400, raw=malformed,
headers={'Content-Type': 'application/json'})
# --- лишнее поле ---
c.call('POST', '/api/v1/users', 400,
body={'username': 'u_' + uuid.uuid4().hex[:8],
'display_name': 'X', 'extra': 'мусор'})
# --- неверный тип поля ---
c.call('POST', '/api/v1/users', 400,
body={'username': 123, 'display_name': 'X'})
# --- пустой display_name ---
c.call('POST', '/api/v1/users', 400,
body={'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': ''})
# --- display_name только из пробелов ---
c.call('POST', '/api/v1/users', 400,
body={'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': ' '})
# --- заглавные в username ---
c.call('POST', '/api/v1/users', 400,
body={'username': 'UPPERCASE', 'display_name': 'X'})
# --- дубликат username ---
c.call('POST', '/api/v1/users', 409, body=alice['registration'])
# --- пустое сообщение ---
c.call('POST', path + '/messages', 400, actor=alice, body={'text': ''})
# --- сообщение только из пробелов ---
c.call('POST', path + '/messages', 400, actor=alice, body={'text': ' '})
# --- чужой чат ---
c.call('GET', path, 404, actor=eve)
c.call('GET', path + '/messages', 404, actor=eve)
c.call('POST', path + '/messages', 404, actor=eve, body={'text': 'чужое'})
# --- чат без создателя в member_ids ---
c.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'Без меня', 'member_ids': [bob['id']]})
# --- чат с неизвестным участником ---
c.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'С фантомом',
'member_ids': [alice['id'], '00000000-0000-4000-8000-000000000000']})
# --- чат с дубликатами ---
c.call('POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'Дубликаты', 'member_ids': [alice['id'], alice['id']]})
# --- обход нескольких страниц ---
for i in range(5):
c.message(alice, chat, 'page-test-%d' % i)
seen = []
cursor = None
for _ in range(20):
query = path + '/messages?limit=2'
if cursor:
from urllib.parse import quote
query += '&cursor=' + quote(cursor, safe='')
page = c.call('GET', query, actor=alice, schema='MessagePage')['json']
seen.extend(x['id'] for x in page['items'])
cursor = page['next_cursor']
if cursor is None:
break
check(len(seen) == len(set(seen)), 'пагинация вернула дубликаты')
check(len(seen) >= 5, 'пагинация потеряла сообщения')
# --- cursor от другого чата ---
other_chat = c.call('POST', '/api/v1/chats', 201, actor=alice,
body={'title': 'Другой чат',
'member_ids': [alice['id'], bob['id']]},
schema='Chat')['json']
other_path = '/api/v1/chats/' + other_chat['id']
c.message(alice, other_chat, 'other-1')
c.message(alice, other_chat, 'other-2')
other_page = c.call('GET', other_path + '/messages?limit=1', actor=alice,
schema='MessagePage')['json']
other_cursor = other_page['next_cursor']
check(other_cursor is not None, 'ожидался cursor от другого чата, но получен null')
from urllib.parse import quote
c.call('GET', path + '/messages?limit=2&cursor=' + quote(other_cursor, safe=''),
400, actor=alice)
print('PASS: негативные сценарии прошли')
if __name__ == '__main__':
run(main)
+81
View File
@@ -0,0 +1,81 @@
#!/usr/bin/env python3
import threading
import uuid
from concurrent.futures import ThreadPoolExecutor
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, LAB, Failure, arguments, check, run # noqa: E402
def main():
args = arguments('Собственные тесты конкурентности')
c = Client(args.base_url, args.ca_file)
alice, bob, eve, chat = c.bootstrap()
path = '/api/v1/chats/' + chat['id']
# --- 100 сообщений от 10 потоков ---
workers = 10
per_worker = 10
expected_total = workers * per_worker
barrier = threading.Barrier(workers)
def writer(worker_id):
local = Client(args.base_url, args.ca_file, timeout=10)
barrier.wait()
for i in range(per_worker):
local.message(alice, chat, 'c-%d-%d' % (worker_id, i))
with ThreadPoolExecutor(max_workers=workers) as pool:
list(pool.map(writer, range(workers)))
seen = []
cursor = None
while True:
q = path + '/messages?limit=100'
if cursor:
from urllib.parse import quote
q += '&cursor=' + quote(cursor, safe='')
page = c.call('GET', q, actor=alice, schema='MessagePage')['json']
seen.extend(x['id'] for x in page['items'])
cursor = page['next_cursor']
if cursor is None:
break
check(len(seen) == len(set(seen)), 'после параллельной записи обнаружены дубликаты id сообщений')
check(len(seen) == expected_total,
'ожидалось ровно %d сообщений, получено %d' % (expected_total, len(seen)))
# --- гонка за username ---
username = 'race_' + uuid.uuid4().hex[:8]
password = 'T3st-' + uuid.uuid4().hex
body = {'username': username, 'display_name': 'Race', 'password': password}
barrier2 = threading.Barrier(workers)
def register(_):
local = Client(args.base_url, args.ca_file, timeout=10)
barrier2.wait()
try:
local.call('POST', '/api/v1/users', 201, body=body)
return 'ok'
except Failure:
return 'conflict'
with ThreadPoolExecutor(max_workers=workers) as pool:
results = list(pool.map(register, range(workers)))
ok_count = results.count('ok')
conflict_count = results.count('conflict')
check(ok_count == 1, 'ожидалась ровно одна успешная регистрация, получено %d' % ok_count)
check(conflict_count == workers - 1,
'ожидалось %d конфликтов, получено %d' % (workers - 1, conflict_count))
print('PASS: конкурентность (100 сообщений, 1 победитель в гонке за username)')
if __name__ == '__main__':
run(main)
+46
View File
@@ -0,0 +1,46 @@
#!/usr/bin/env python3
import base64
import time
import uuid
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, arguments, check, run # noqa: E402
def main():
args = arguments('Истечение сессии. Требует SESSION_TTL_SECONDS=2')
c = Client(args.base_url, args.ca_file)
username = 'exp_' + uuid.uuid4().hex[:10]
password = 'T3st-' + uuid.uuid4().hex
c.call('POST', '/api/v1/users', 201, body={
'username': username, 'display_name': 'Exp', 'password': password})
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
s = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')['json']
actor = {'id': s['user']['id'], 'token': s['token']}
# сразу после логина — работает
c.call('GET', '/api/v1/users/me', actor=actor, schema='User')
# ждём больше TTL. Если TTL не 2, тест упадёт с понятным сообщением
# (см. проверку ниже по факту отказа).
time.sleep(3.5)
# ожидаем 401 с Bearer challenge
r = c.call('GET', '/api/v1/users/me', 401, actor=actor)
challenge = r['headers'].get('WWW-Authenticate', '')
check(challenge.lower().startswith('bearer'),
f'ожидался WWW-Authenticate: Bearer, получено {challenge!r}')
# и сразу проверяем, что до истечения он работал — уже сделано выше
print('PASS: сессия истекла после TTL и вернула 401 Bearer')
if __name__ == '__main__':
run(main)
+89
View File
@@ -0,0 +1,89 @@
#!/usr/bin/env python3
import argparse
import subprocess
import time
import uuid
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, check, run # noqa: E402
REPO_ROOT = ROOT
def compose(*args, timeout=90):
return subprocess.run(
['docker', 'compose', '--env-file', '.env', *args],
cwd=REPO_ROOT, capture_output=True, text=True, timeout=timeout,
)
def make_user(c):
username = 'rs_' + uuid.uuid4().hex[:10]
password = 'T3st-' + uuid.uuid4().hex
c.call('POST', '/api/v1/users', 201, body={
'username': username, 'display_name': 'Res', 'password': password})
import base64
cred = base64.b64encode(f'{username}:{password}'.encode()).decode()
s = c.call('POST', '/api/v1/auth/sessions', 201,
headers={'Authorization': 'Basic ' + cred}, schema='Session')['json']
return {'id': s['user']['id'], 'token': s['token']}
def wait_ready(c, seconds=90):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
c.call('GET', '/health/ready', schema='Health')
return
except Exception:
time.sleep(1)
raise RuntimeError('health/ready не восстановился за %d секунд' % seconds)
def main():
p = argparse.ArgumentParser()
p.add_argument('--service', choices=['redis', 'postgres'], required=True)
p.add_argument('--base-url', default=None)
args = p.parse_args()
c = Client(args.base_url)
alice = make_user(c)
c.call('GET', '/api/v1/users/me', actor=alice, schema='User')
print(f'[{args.service}] останавливаем сервис')
r = compose('stop', args.service)
check(r.returncode == 0, f'docker compose stop: {r.stderr.strip()}')
try:
time.sleep(2)
# Защищённый endpoint должен вернуть 503 unavailable.
resp = c.call('GET', '/api/v1/users/me', 503, actor=alice)
code = resp['json']['error']['code']
check(code == 'unavailable',
f'ожидался код unavailable, получено {code!r}')
# Сообщение не должно раскрывать детали про Redis/Postgres/сеть.
msg = resp['json']['error']['message'].lower()
for bad in ('redis', 'postgres', 'sql', 'connection', 'refused', 'dial'):
check(bad not in msg, f'сообщение раскрывает "{bad}": {msg}')
# Здоровье тоже должно репортить 503.
c.call('GET', '/health/ready', 503)
finally:
print(f'[{args.service}] запускаем сервис обратно')
r = compose('start', args.service)
check(r.returncode == 0, f'docker compose start: {r.stderr.strip()}')
wait_ready(c)
# Токен alice всё ещё валиден после возврата сервиса.
c.call('GET', '/api/v1/users/me', actor=alice, schema='User')
print(f'PASS: {args.service} недоступен → 503 unavailable без утечек; восстановление OK')
if __name__ == '__main__':
run(main)
+74
View File
@@ -0,0 +1,74 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
mkdir -p evidence
COMPOSE="docker compose"
if ! $COMPOSE version >/dev/null 2>&1; then
COMPOSE="docker-compose"
fi
psql() {
$COMPOSE --env-file .env exec -T postgres \
psql -U messenger -d messenger -v ON_ERROR_STOP=1 "$@"
}
N=5000
CHAT_ID=$(psql -t -A -c "SELECT id FROM chats WHERE title='hot' LIMIT 1")
USER_ID=$(psql -t -A -c "SELECT id FROM users LIMIT 1")
if [ -z "$CHAT_ID" ] || [ -z "$USER_ID" ]; then
echo "Нет тестового чата 'hot' или пользователя. Сначала запустите seed_large.py" >&2
exit 2
fi
reset_indexes() {
psql -c "DROP INDEX IF EXISTS messages_covering_small;
DROP INDEX IF EXISTS messages_chat_created_id_idx;" >/dev/null
}
bench() {
label="$1"
echo "## $label"
psql <<SQL
\\timing on
DO \$\$
DECLARE i int;
BEGIN
FOR i IN 1..$N LOOP
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (gen_random_uuid(), '$CHAT_ID'::uuid, '$USER_ID'::uuid,
'bench ' || i, now());
END LOOP;
END \$\$;
SQL
psql -c "SELECT indexname, pg_size_pretty(pg_relation_size(indexname::regclass)) AS size
FROM pg_indexes WHERE tablename='messages' ORDER BY indexname;"
echo
}
{
echo "# Стоимость записи: $N INSERT в один чат"
echo "# date: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
echo "# chat_id: $CHAT_ID"
echo
echo "## A. Baseline (chat_id, created_at, id)"
reset_indexes
psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);" >/dev/null
bench "INSERT $N rows"
psql -c "DELETE FROM messages WHERE text LIKE 'bench %';" >/dev/null
echo
echo "## B. Covering (chat_id, created_at, id) INCLUDE (sender_id)"
reset_indexes
psql -c "CREATE INDEX messages_covering_small ON messages (chat_id, created_at, id) INCLUDE (sender_id);" >/dev/null
bench "INSERT $N rows"
psql -c "DELETE FROM messages WHERE text LIKE 'bench %';" >/dev/null
echo
echo "## Восстанавливаем baseline"
reset_indexes
psql -c "CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); ANALYZE messages;" >/dev/null
} | tee evidence/write_cost.txt