Перенести мессенджер на PostgreSQL и сессии Redis.
Skeleton contracts / contracts (pull_request) Canceled after 0s
Skeleton contracts / contracts (pull_request) Canceled after 0s
Сообщения должны переживать рестарт, а доступ идти через Bearer, а не X-User-Id. Трек 2 сравнивает план keyset-запроса и сверяет pg_restore.
This commit is contained in:
+11
-7
@@ -1,11 +1,15 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
# Локальные учебные значения. Скопируйте в .env и не коммитьте .env.
|
||||
# Пароль ниже — синтетический пароль стенда, не секрет продакшена.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
APP_ACCESS_LOG=1
|
||||
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=messenger
|
||||
POSTGRES_DB=messenger
|
||||
|
||||
# Внутри сети Compose хост базы — postgres, хост Redis — redis.
|
||||
DATABASE_URL=postgres://messenger:messenger@postgres:5432/messenger?sslmode=disable
|
||||
REDIS_URL=redis://redis:6379/0
|
||||
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
# syntax=docker/dockerfile:1.7
|
||||
FROM golang:1.23.8-bookworm AS build
|
||||
WORKDIR /src
|
||||
COPY go.mod go.sum ./
|
||||
RUN go mod download
|
||||
COPY cmd ./cmd
|
||||
COPY internal ./internal
|
||||
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/server ./cmd/server
|
||||
|
||||
FROM gcr.io/distroless/static-debian12:nonroot
|
||||
COPY --from=build /out/server /server
|
||||
USER nonroot:nonroot
|
||||
EXPOSE 8080
|
||||
ENV APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080 \
|
||||
APP_ENV=lab \
|
||||
SESSION_TTL_SECONDS=3600
|
||||
HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=5 \
|
||||
CMD ["/server", "-healthcheck"]
|
||||
ENTRYPOINT ["/server"]
|
||||
@@ -4,7 +4,9 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
GO ?= go
|
||||
|
||||
.PHONY: help check validate test load test-persistence student-test track2
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@@ -24,3 +26,9 @@ load:
|
||||
test-persistence:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
student-test:
|
||||
$(GO) test ./student-tests/ -v -count=1 -timeout 180s
|
||||
|
||||
track2:
|
||||
bash scripts/run_track2.sh
|
||||
|
||||
@@ -1,37 +1,93 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Белоусов Анатолий Фахраддинович, БПИ2303
|
||||
- Целевая оценка; выбранный трек 5: **5, трек 2** (план запроса и восстановление)
|
||||
- Commit/PR: ветка `solution/bpi2303-belousov`
|
||||
- Использованные источники, библиотеки и помощь ИИ: Go `net/http`, `pgx` v5, `go-redis` v9, `golang.org/x/crypto/argon2`, `google/uuid`; публичные `tests/`; Cursor/Composer для реализации и прогонов. Пароли — Argon2id, не bcrypt: bcrypt обрезает пароль на 72 байта, а контракт разрешает до 128 code points.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Docker, Go 1.23+ (собственные тесты и трек 2), Python 3.9+.
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
docker compose --env-file .env up -d --build
|
||||
# дождаться {"status":"ok"} на http://127.0.0.1:8080/health/ready
|
||||
make test
|
||||
make student-test
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
bash scripts/check_deps.sh
|
||||
bash scripts/run_track2.sh
|
||||
```
|
||||
|
||||
Остановка без удаления данных: `docker compose --env-file .env stop`.
|
||||
Удаление учебных volumes: `docker compose --env-file .env down -v`.
|
||||
|
||||
Образы: сборка `golang:1.23.8-bookworm`, runtime `gcr.io/distroless/static-debian12:nonroot`, PostgreSQL `postgres:16.6`, Redis `redis:7.4.1` с `appendonly yes` и `appendfsync everysec`.
|
||||
|
||||
Соответствие `.env.example`: `DATABASE_URL` и `REDIS_URL` задаются контейнеру явно. `DATABASE_URL_FILE` / `CACHE_URL_FILE` тоже читаются, если прямого URL нет. `SESSION_TTL_SECONDS` по умолчанию 3600. Пароль `messenger` в example — синтетический пароль локального стенда.
|
||||
|
||||
Миграции вшиты в бинарник и применяются при старте. Повторный старт не дублирует строки: версия лежит в `schema_migrations`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Клиент → API (один процесс) → PostgreSQL для пользователей, чатов, состава и сообщений. Redis хранит только сессии.
|
||||
|
||||
Пароль проверяется Argon2id (`m=19456,t=2,p=1`). В Redis лежит SHA-256 токена, не сам токен. Токен — 32 случайных байта (256 бит), клиенту отдаётся hex. TTL ключа равен оставшемуся сроку сессии и рестартом API не продлевается. AOF на volume переживает рестарт Redis. `kill -9` процесса Redis может потерять около секунды записей (`appendfsync everysec`) — это граница durability, не «данные вечны».
|
||||
|
||||
`POST /auth/sessions` принимает только Basic. Остальные защищённые методы — только Bearer. `X-User-Id` не читается. Недоступные Postgres или Redis дают 503, а не успех от имени анонима.
|
||||
|
||||
Создание чата — одна транзакция: строка чата и все участники фиксируются вместе. Неизвестный участник откатывает вставку. Гонка одинакового username закрыта `UNIQUE`, а не проверкой «сначала SELECT».
|
||||
|
||||
История читается keyset-запросом `(created_at, id)` по индексу `messages_history_idx (chat_id, created_at, id)`. Кэша истории нет, поэтому успешная запись видна следующему чтению без инвалидации. Пул: до 10 соединений, `statement_timeout=3s`, таймаут подключения 2s.
|
||||
|
||||
Из lab1 перенесены контрактные правила пользователей/чатов/сообщений, opaque cursor, non-root образ, healthcheck и остановка по SIGTERM за ≤10 с. Идентификация заменена с `X-User-Id` на сессию, память процесса больше не хранит данные.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
Стенд прогона: macOS, 8 CPU, 8 GiB RAM, Docker Desktop, лимиты контейнеров не заданы (NanoCpus=0, Memory=0). Дата прогона: 2026-10-14.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke-pass.txt` |
|
||||
| Сохранность данных и сессии | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `evidence/persistence.txt` |
|
||||
| Повтор миграций, JSON, чужой чат, пустой текст | `make student-test` | `ok student-tests` | `evidence/student-test.txt` |
|
||||
| Гонка username | 8 параллельных POST одного username | 1×201 и 7×409 | `evidence/student-test.txt` |
|
||||
| Откат создания чата | неизвестный участник | 400, строк с этим title: 0 | `evidence/student-test.txt` |
|
||||
| Неверный пароль, logout, X-User-Id, Basic на /users/me | student-test | 401, после logout повторный DELETE тоже 401 | `evidence/student-test.txt` |
|
||||
| Короткий TTL | `SESSION_TTL=2s`, пауза 2.5 с | 401 | `evidence/student-test.txt` |
|
||||
| Redis/Postgres недоступны | `scripts/check_deps.sh` и закрытый клиент Redis | `/health/ready` = 503, Bearer не становится 200; после start снова 200 | `evidence/deps-down.txt`, `evidence/student-test.txt` |
|
||||
| EXPLAIN на большой истории | трек 2, чат 74449 сообщений | см. ниже | `evidence/track2/` |
|
||||
| Backup и сверка | `pg_dump -Fc` → новая база | 100000 сообщений, checksum совпал | `evidence/track2/restore.json` |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
`scripts/restart.sh` перезапускает postgres, redis и api и не вызывает `down -v`. До и после прогона контейнеры — `mtusi2026lab2-api-1`, `mtusi2026lab2-postgres-1`, `mtusi2026lab2-redis-1`.
|
||||
|
||||
## Эксперименты и отказы
|
||||
## Эксперименты и отказы (трек 2)
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
**Гипотеза.** Индекс только по `chat_id` заставляет для keyset-страницы в середине большого чата прочитать хвост истории и отсортировать его. Индекс `(chat_id, created_at, id)` отдаёт страницу прямым чтением. Второй индекс почти не меняет стоимость вставки на 5000 строк.
|
||||
|
||||
**Методика.** Отдельная база `track2`, не стенд smoke. 6 чатов размерами 1, 50, 500, 5000, 20000 и 74449 (сумма 100000). Запрос — keyset `LIMIT 50` от сообщения с OFFSET 30000 в самом большом чате. Два плана: `EXPLAIN (ANALYZE, BUFFERS)`. Затем вставка 5000 строк в отдельную таблицу с одним индексом и с двумя. Потом `pg_dump -Fc` и `pg_restore` в новую базу `track2_restore`. Сверка: число чатов и сообщений, SHA-256 потока `(id, created_at, text)` и id первого сообщения большого чата. Повтор: `bash scripts/run_track2.sh`.
|
||||
|
||||
**Чтение.**
|
||||
|
||||
| План | Корневой узел | Что под ним | Execution Time | Shared Hit Blocks |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| Только `chat_id` | Limit | Sort → Bitmap Heap Scan 44448 строк | 16.435 ms | 847 |
|
||||
| `(chat_id, created_at, id)` | Limit | Index Only Scan ровно 50 строк | 0.091 ms | 1 |
|
||||
|
||||
Слабый план прочитал десятки тысяч строк чата. Рабочий план прочитал страницу. В продовой миграции оставлен только составной индекс.
|
||||
|
||||
**Запись.** 5000 строк: 30 ms с индексом `chat_id` и 31 ms с двумя индексами. На этом объёме цена второго индекса теряется в шуме. Утверждать, что индекс «бесплатный навсегда», нельзя: при гораздо большей скорости вставки он начнёт быть виден.
|
||||
|
||||
**Восстановление.** Counts и checksum совпали, 100000 = 100000. Дамп снят после COMMIT загрузки, поэтому сверка не показывает потерю незафиксированных строк. `appendfsync everysec` у Redis к этому дампу не относится: в дампе только PostgreSQL.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `scripts/restart.sh` | те же сообщения и тот же токен | PASS persistence | API дождался Postgres и поднялся в пределах 90 с теста; подтверждённые строки на месте |
|
||||
| `docker compose stop redis` | `/health/ready` 503, не анонимный 200 | 503, затем 200 | около секунды после start |
|
||||
| `docker compose stop postgres` | то же для БД | 503, затем 200 | около секунды после start |
|
||||
| `pg_restore` в новую базу | те же 100000 строк | checksum совпал | дамп консистентен на момент `pg_dump`; незакоммиченное не входило |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Один Docker-host не переживает потерю машины. Рестарт Redis с AOF `everysec` может потерять последнюю секунду новых сессий при жёстком убийстве процесса. История сообщений не кэшируется: read-after-write здесь свойство PostgreSQL, а не инвалидации кэша. Разница стоимости записи двух индексов на 5000 строках не доказана. `EXPLAIN ANALYZE` — один прогон на локальном диске Docker, не распределённый бенчмарк.
|
||||
|
||||
@@ -0,0 +1,158 @@
|
||||
// Точка входа HTTP API.
|
||||
//
|
||||
// Процесс поднимает пул PostgreSQL, применяет миграции, проверяет Redis и только потом слушает порт.
|
||||
// SIGTERM переводит /health/ready в 503 и даёт текущим запросам до 10 секунд на завершение.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"flag"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"mtusi2026lab2/internal/api"
|
||||
"mtusi2026lab2/internal/auth"
|
||||
"mtusi2026lab2/internal/config"
|
||||
"mtusi2026lab2/internal/session"
|
||||
"mtusi2026lab2/internal/store"
|
||||
)
|
||||
|
||||
func main() {
|
||||
healthcheck := flag.Bool("healthcheck", false, "probe local /health/ready and exit")
|
||||
flag.Parse()
|
||||
if *healthcheck {
|
||||
os.Exit(runHealthcheck())
|
||||
}
|
||||
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
log.Fatalf("config: %v", err)
|
||||
}
|
||||
hasher, err := auth.NewHasher()
|
||||
if err != nil {
|
||||
log.Fatalf("password hasher: %v", err)
|
||||
}
|
||||
|
||||
rootCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
|
||||
defer stop()
|
||||
|
||||
// docker compose restart поднимает API одновременно с Postgres.
|
||||
// Процесс не выходит сразу: иначе контейнер останется мёртвым, а тест сохранности
|
||||
// не дождётся /health/ready. Ждём хранилища ограниченное время.
|
||||
st, err := waitPostgres(rootCtx, cfg.DatabaseURL, hasher)
|
||||
if err != nil {
|
||||
log.Fatalf("postgres: %v", err)
|
||||
}
|
||||
defer st.Close()
|
||||
if err := st.Migrate(rootCtx); err != nil {
|
||||
log.Fatalf("migrate: %v", err)
|
||||
}
|
||||
sessions, err := waitRedis(rootCtx, cfg.RedisURL, cfg.SessionTTL)
|
||||
if err != nil {
|
||||
log.Fatalf("redis: %v", err)
|
||||
}
|
||||
defer sessions.Close()
|
||||
|
||||
srvAPI := api.New(st, sessions)
|
||||
httpServer := &http.Server{
|
||||
Addr: cfg.Addr(),
|
||||
Handler: srvAPI.Handler(),
|
||||
ReadHeaderTimeout: 5 * time.Second,
|
||||
ReadTimeout: 15 * time.Second,
|
||||
WriteTimeout: 15 * time.Second,
|
||||
IdleTimeout: 60 * time.Second,
|
||||
}
|
||||
|
||||
errCh := make(chan error, 1)
|
||||
go func() {
|
||||
log.Printf("listening on %s env=%s session_ttl=%s", cfg.Addr(), cfg.Env, cfg.SessionTTL)
|
||||
if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
|
||||
errCh <- err
|
||||
}
|
||||
}()
|
||||
|
||||
select {
|
||||
case err := <-errCh:
|
||||
log.Fatalf("listen: %v", err)
|
||||
case <-rootCtx.Done():
|
||||
}
|
||||
log.Printf("shutting down")
|
||||
srvAPI.BeginDrain()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
if err := httpServer.Shutdown(ctx); err != nil {
|
||||
log.Printf("shutdown error: %v", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
log.Printf("shutdown complete")
|
||||
}
|
||||
|
||||
func waitPostgres(ctx context.Context, dsn string, hasher *auth.Hasher) (*store.Store, error) {
|
||||
deadline := time.Now().Add(45 * time.Second)
|
||||
var last error
|
||||
for {
|
||||
st, err := store.Open(ctx, dsn, hasher)
|
||||
if err == nil {
|
||||
return st, nil
|
||||
}
|
||||
last = err
|
||||
if ctx.Err() != nil || time.Now().After(deadline) {
|
||||
return nil, last
|
||||
}
|
||||
log.Printf("postgres not ready, retrying")
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
case <-time.After(time.Second):
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func waitRedis(ctx context.Context, redisURL string, ttl time.Duration) (*session.Store, error) {
|
||||
deadline := time.Now().Add(45 * time.Second)
|
||||
var last error
|
||||
for {
|
||||
st, err := session.Open(redisURL, ttl)
|
||||
if err == nil {
|
||||
return st, nil
|
||||
}
|
||||
last = err
|
||||
if ctx.Err() != nil || time.Now().After(deadline) {
|
||||
return nil, last
|
||||
}
|
||||
log.Printf("redis not ready, retrying")
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return nil, ctx.Err()
|
||||
case <-time.After(time.Second):
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func runHealthcheck() int {
|
||||
cfg, err := config.Load()
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
host := cfg.Host
|
||||
if host == "0.0.0.0" || host == "::" {
|
||||
host = "127.0.0.1"
|
||||
}
|
||||
client := &http.Client{Timeout: 2 * time.Second}
|
||||
resp, err := client.Get(fmt.Sprintf("http://%s:%d/health/ready", host, cfg.Port))
|
||||
if err != nil {
|
||||
return 1
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
_, _ = io.Copy(io.Discard, resp.Body)
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
@@ -0,0 +1,509 @@
|
||||
// Команда эксперимента трека 2: план запроса и восстановление.
|
||||
//
|
||||
// Режимы:
|
||||
//
|
||||
// prepare — 100 000 сообщений в чатах неравного размера, база должна называться track2;
|
||||
// explain — слабый индекс (только chat_id) против рабочего (chat_id, created_at, id),
|
||||
// плюс стоимость вставки;
|
||||
// verify — сверка track2 и базы, восстановленной из pg_dump.
|
||||
//
|
||||
// В продовой схеме остаётся только составной индекс. Слабый создаётся на время замера и удаляется.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"flag"
|
||||
"fmt"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
func main() {
|
||||
mode := flag.String("mode", "", "prepare|explain|verify")
|
||||
dsn := flag.String("database-url", "", "postgres URL базы track2")
|
||||
restore := flag.String("restore-url", "", "postgres URL восстановленной базы")
|
||||
outDir := flag.String("out", "evidence/track2", "каталог JSON")
|
||||
flag.Parse()
|
||||
if *mode == "" || *dsn == "" {
|
||||
fmt.Fprintln(os.Stderr, "нужны -mode и -database-url")
|
||||
os.Exit(2)
|
||||
}
|
||||
if !strings.Contains(*dsn, "track2") {
|
||||
fmt.Fprintln(os.Stderr, "отказ: database-url должен указывать на базу track2, чтобы не затереть стенд smoke")
|
||||
os.Exit(2)
|
||||
}
|
||||
ctx := context.Background()
|
||||
switch *mode {
|
||||
case "prepare":
|
||||
if err := prepare(ctx, *dsn); err != nil {
|
||||
fail(err)
|
||||
}
|
||||
case "explain":
|
||||
if err := explain(ctx, *dsn, *outDir); err != nil {
|
||||
fail(err)
|
||||
}
|
||||
case "verify":
|
||||
if *restore == "" || !strings.Contains(*restore, "track2_restore") {
|
||||
fmt.Fprintln(os.Stderr, "нужен -restore-url на базу track2_restore")
|
||||
os.Exit(2)
|
||||
}
|
||||
if err := verify(ctx, *dsn, *restore, *outDir); err != nil {
|
||||
fail(err)
|
||||
}
|
||||
default:
|
||||
fmt.Fprintln(os.Stderr, "неизвестный mode")
|
||||
os.Exit(2)
|
||||
}
|
||||
}
|
||||
|
||||
func prepare(ctx context.Context, dsn string) error {
|
||||
pool, err := open(ctx, dsn)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer pool.Close()
|
||||
// Та же схема, что у API, но без statement_timeout: загрузка 100k не должна обрываться.
|
||||
if err := applySchema(ctx, pool); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `TRUNCATE messages, chat_members, chats, users`); err != nil {
|
||||
return err
|
||||
}
|
||||
userID := uuid.New()
|
||||
now := time.Now().UTC().Truncate(time.Millisecond)
|
||||
if _, err := pool.Exec(ctx, `
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES ($1, 'track2_user', 'Трек 2', 'not-a-login-hash', $2)`, userID, now); err != nil {
|
||||
return err
|
||||
}
|
||||
// Сумма размеров = 100 000. Один чат сильно больше остальных — так план на «горячей» истории
|
||||
// не маскируется равномерным распределением.
|
||||
sizes := []int{1, 50, 500, 5000, 20000, 74449}
|
||||
sum := 0
|
||||
for _, n := range sizes {
|
||||
sum += n
|
||||
}
|
||||
if sum != 100000 {
|
||||
return fmt.Errorf("sizes sum %d", sum)
|
||||
}
|
||||
type chat struct {
|
||||
id uuid.UUID
|
||||
size int
|
||||
}
|
||||
chats := make([]chat, len(sizes))
|
||||
for i, n := range sizes {
|
||||
chats[i] = chat{id: uuid.New(), size: n}
|
||||
if _, err := pool.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`,
|
||||
chats[i].id, fmt.Sprintf("chat-%d", n), now.Add(time.Duration(i)*time.Millisecond)); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)`, chats[i].id, userID); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
rows := make([][]any, 0, 1000)
|
||||
flush := func() error {
|
||||
if len(rows) == 0 {
|
||||
return nil
|
||||
}
|
||||
_, err := pool.CopyFrom(ctx, pgx.Identifier{"messages"},
|
||||
[]string{"id", "chat_id", "sender_id", "text", "created_at"}, pgx.CopyFromRows(rows))
|
||||
rows = rows[:0]
|
||||
return err
|
||||
}
|
||||
for _, c := range chats {
|
||||
for i := 0; i < c.size; i++ {
|
||||
rows = append(rows, []any{
|
||||
uuid.New(),
|
||||
c.id,
|
||||
userID,
|
||||
fmt.Sprintf("m-%d", i),
|
||||
now.Add(time.Duration(i) * time.Millisecond),
|
||||
})
|
||||
if len(rows) == 1000 {
|
||||
if err := flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if err := flush(); err != nil {
|
||||
return err
|
||||
}
|
||||
var n int
|
||||
if err := pool.QueryRow(ctx, `SELECT count(*) FROM messages`).Scan(&n); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("prepared messages=%d chats=%d\n", n, len(chats))
|
||||
if n != 100000 {
|
||||
return fmt.Errorf("expected 100000 messages, got %d", n)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func explain(ctx context.Context, dsn, outDir string) error {
|
||||
if err := os.MkdirAll(outDir, 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
pool, err := open(ctx, dsn)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer pool.Close()
|
||||
var chatID uuid.UUID
|
||||
var size int
|
||||
if err := pool.QueryRow(ctx, `
|
||||
SELECT chat_id, count(*) FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1`,
|
||||
).Scan(&chatID, &size); err != nil {
|
||||
return err
|
||||
}
|
||||
var curAt time.Time
|
||||
var curID uuid.UUID
|
||||
// Середина большой истории: keyset не должен для каждой страницы читать все предыдущие строки.
|
||||
if err := pool.QueryRow(ctx, `
|
||||
SELECT created_at, id FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
OFFSET 30000 LIMIT 1`, chatID).Scan(&curAt, &curID); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
weak, err := withIndex(ctx, pool, false, func() (map[string]any, error) {
|
||||
return explainQuery(ctx, pool, chatID, curAt, curID)
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("weak plan: %w", err)
|
||||
}
|
||||
strong, err := withIndex(ctx, pool, true, func() (map[string]any, error) {
|
||||
return explainQuery(ctx, pool, chatID, curAt, curID)
|
||||
})
|
||||
if err != nil {
|
||||
return fmt.Errorf("strong plan: %w", err)
|
||||
}
|
||||
writeCost, err := measureInsert(ctx, pool, chatID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
summary := map[string]any{
|
||||
"largest_chat_messages": size,
|
||||
"cursor_offset": 30000,
|
||||
"weak_index": "messages_chat_only_idx (chat_id)",
|
||||
"strong_index": "messages_history_idx (chat_id, created_at, id)",
|
||||
"weak_plan": summarizePlan(weak),
|
||||
"strong_plan": summarizePlan(strong),
|
||||
"write_cost": writeCost,
|
||||
}
|
||||
if err := writeJSON(outDir+"/explain-weak.json", weak); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := writeJSON(outDir+"/explain-strong.json", strong); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := writeJSON(outDir+"/summary.json", summary); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("weak: %s\nstrong: %s\nwrite: %+v\n", summarizePlan(weak), summarizePlan(strong), writeCost)
|
||||
return nil
|
||||
}
|
||||
|
||||
func verify(ctx context.Context, srcDSN, dstDSN, outDir string) error {
|
||||
src, err := open(ctx, srcDSN)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer src.Close()
|
||||
dst, err := open(ctx, dstDSN)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer dst.Close()
|
||||
srcCount, srcSum, err := fingerprint(ctx, src)
|
||||
if err != nil {
|
||||
return fmt.Errorf("source: %w", err)
|
||||
}
|
||||
dstCount, dstSum, err := fingerprint(ctx, dst)
|
||||
if err != nil {
|
||||
return fmt.Errorf("restore: %w", err)
|
||||
}
|
||||
var srcSample, dstSample string
|
||||
q := `
|
||||
SELECT id::text FROM messages m
|
||||
JOIN (SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1) big
|
||||
ON big.chat_id = m.chat_id
|
||||
ORDER BY m.created_at, m.id
|
||||
LIMIT 1`
|
||||
if err := src.QueryRow(ctx, q).Scan(&srcSample); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := dst.QueryRow(ctx, q).Scan(&dstSample); err != nil {
|
||||
return err
|
||||
}
|
||||
report := map[string]any{
|
||||
"source_messages": srcCount.messages,
|
||||
"restore_messages": dstCount.messages,
|
||||
"source_chats": srcCount.chats,
|
||||
"restore_chats": dstCount.chats,
|
||||
"source_sha256": srcSum,
|
||||
"restore_sha256": dstSum,
|
||||
"source_first_id": srcSample,
|
||||
"restore_first_id": dstSample,
|
||||
"counts_match": srcCount == dstCount,
|
||||
"checksum_match": srcSum == dstSum,
|
||||
"first_id_match": srcSample == dstSample,
|
||||
}
|
||||
if err := os.MkdirAll(outDir, 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := writeJSON(outDir+"/restore.json", report); err != nil {
|
||||
return err
|
||||
}
|
||||
fmt.Printf("restore match counts=%v checksum=%v first=%v messages=%d\n",
|
||||
srcCount == dstCount, srcSum == dstSum, srcSample == dstSample, srcCount.messages)
|
||||
if srcCount != dstCount || srcSum != dstSum || srcSample != dstSample {
|
||||
return fmt.Errorf("restore mismatch")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type counts struct {
|
||||
messages int
|
||||
chats int
|
||||
}
|
||||
|
||||
func fingerprint(ctx context.Context, pool *pgxpool.Pool) (counts, string, error) {
|
||||
var c counts
|
||||
if err := pool.QueryRow(ctx, `SELECT count(*) FROM messages`).Scan(&c.messages); err != nil {
|
||||
return c, "", err
|
||||
}
|
||||
if err := pool.QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&c.chats); err != nil {
|
||||
return c, "", err
|
||||
}
|
||||
rows, err := pool.Query(ctx, `SELECT id::text, created_at::text, text FROM messages ORDER BY created_at, id`)
|
||||
if err != nil {
|
||||
return c, "", err
|
||||
}
|
||||
defer rows.Close()
|
||||
h := sha256.New()
|
||||
for rows.Next() {
|
||||
var id, ts, text string
|
||||
if err := rows.Scan(&id, &ts, &text); err != nil {
|
||||
return c, "", err
|
||||
}
|
||||
_, _ = fmt.Fprintf(h, "%s|%s|%s\n", id, ts, text)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return c, "", err
|
||||
}
|
||||
return c, hex.EncodeToString(h.Sum(nil)), nil
|
||||
}
|
||||
|
||||
func withIndex(ctx context.Context, pool *pgxpool.Pool, strong bool, fn func() (map[string]any, error)) (map[string]any, error) {
|
||||
if _, err := pool.Exec(ctx, `DROP INDEX IF EXISTS messages_history_idx`); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `DROP INDEX IF EXISTS messages_chat_only_idx`); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var create string
|
||||
if strong {
|
||||
create = `CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id)`
|
||||
} else {
|
||||
create = `CREATE INDEX messages_chat_only_idx ON messages (chat_id)`
|
||||
}
|
||||
if _, err := pool.Exec(ctx, create); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
plan, err := fn()
|
||||
// Продовый индекс возвращаем даже если замер упал.
|
||||
_, _ = pool.Exec(ctx, `DROP INDEX IF EXISTS messages_chat_only_idx`)
|
||||
_, recErr := pool.Exec(ctx, `CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id)`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if recErr != nil {
|
||||
return nil, recErr
|
||||
}
|
||||
return plan, nil
|
||||
}
|
||||
|
||||
func explainQuery(ctx context.Context, pool *pgxpool.Pool, chatID uuid.UUID, curAt time.Time, curID uuid.UUID) (map[string]any, error) {
|
||||
var raw []byte
|
||||
err := pool.QueryRow(ctx, `
|
||||
EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)
|
||||
SELECT id, created_at FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT 50`, chatID, curAt, curID).Scan(&raw)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var parsed any
|
||||
if err := json.Unmarshal(raw, &parsed); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return map[string]any{"explain": parsed}, nil
|
||||
}
|
||||
|
||||
func measureInsert(ctx context.Context, pool *pgxpool.Pool, chatID uuid.UUID) (map[string]any, error) {
|
||||
var userID uuid.UUID
|
||||
if err := pool.QueryRow(ctx, `SELECT user_id FROM chat_members WHERE chat_id = $1`, chatID).Scan(&userID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `DROP TABLE IF EXISTS messages_write_probe`); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `
|
||||
CREATE TABLE messages_write_probe (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL,
|
||||
sender_id uuid NOT NULL,
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL
|
||||
)`); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer pool.Exec(ctx, `DROP TABLE IF EXISTS messages_write_probe`)
|
||||
one, err := timedInsert(ctx, pool, chatID, userID, `CREATE INDEX probe_chat ON messages_write_probe (chat_id)`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `TRUNCATE messages_write_probe`); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `DROP INDEX IF EXISTS probe_chat`); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
both, err := timedInsert(ctx, pool, chatID, userID, `
|
||||
CREATE INDEX probe_chat ON messages_write_probe (chat_id);
|
||||
CREATE INDEX probe_hist ON messages_write_probe (chat_id, created_at, id)`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return map[string]any{
|
||||
"rows": 5000,
|
||||
"only_chat_id_index_ms": one,
|
||||
"chat_id_plus_history_ms": both,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func timedInsert(ctx context.Context, pool *pgxpool.Pool, chatID, userID uuid.UUID, indexSQL string) (int64, error) {
|
||||
for _, stmt := range strings.Split(indexSQL, ";") {
|
||||
stmt = strings.TrimSpace(stmt)
|
||||
if stmt == "" {
|
||||
continue
|
||||
}
|
||||
if _, err := pool.Exec(ctx, stmt); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
}
|
||||
rows := make([][]any, 5000)
|
||||
base := time.Now().UTC()
|
||||
for i := range rows {
|
||||
rows[i] = []any{uuid.New(), chatID, userID, "w", base.Add(time.Duration(i) * time.Millisecond)}
|
||||
}
|
||||
start := time.Now()
|
||||
_, err := pool.CopyFrom(ctx, pgx.Identifier{"messages_write_probe"},
|
||||
[]string{"id", "chat_id", "sender_id", "text", "created_at"}, pgx.CopyFromRows(rows))
|
||||
return time.Since(start).Milliseconds(), err
|
||||
}
|
||||
|
||||
func summarizePlan(plan map[string]any) string {
|
||||
list, _ := plan["explain"].([]any)
|
||||
if len(list) == 0 {
|
||||
return "empty"
|
||||
}
|
||||
root, _ := list[0].(map[string]any)
|
||||
p, _ := root["Plan"].(map[string]any)
|
||||
node, _ := p["Node Type"].(string)
|
||||
return fmt.Sprintf("node=%s execution_ms=%v shared_hit_blocks=%v sort=%v",
|
||||
node, root["Execution Time"], p["Shared Hit Blocks"], hasNode(p, "Sort"))
|
||||
}
|
||||
|
||||
func hasNode(plan map[string]any, name string) bool {
|
||||
if plan == nil {
|
||||
return false
|
||||
}
|
||||
if plan["Node Type"] == name {
|
||||
return true
|
||||
}
|
||||
children, _ := plan["Plans"].([]any)
|
||||
for _, child := range children {
|
||||
m, _ := child.(map[string]any)
|
||||
if hasNode(m, name) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func applySchema(ctx context.Context, pool *pgxpool.Pool) error {
|
||||
stmts := []string{
|
||||
`CREATE TABLE IF NOT EXISTS users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL UNIQUE,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL)`,
|
||||
`CREATE TABLE IF NOT EXISTS chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL)`,
|
||||
`CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
PRIMARY KEY (chat_id, user_id))`,
|
||||
`CREATE TABLE IF NOT EXISTS messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL)`,
|
||||
`CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id)`,
|
||||
}
|
||||
for _, stmt := range stmts {
|
||||
if _, err := pool.Exec(ctx, stmt); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func open(ctx context.Context, dsn string) (*pgxpool.Pool, error) {
|
||||
cfg, err := pgxpool.ParseConfig(dsn)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
cfg.MaxConns = 4
|
||||
cfg.ConnConfig.ConnectTimeout = 5 * time.Second
|
||||
pool, err := pgxpool.NewWithConfig(ctx, cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := pool.Ping(ctx); err != nil {
|
||||
pool.Close()
|
||||
return nil, err
|
||||
}
|
||||
_, _ = pool.Exec(ctx, `SET statement_timeout = 0`)
|
||||
return pool, nil
|
||||
}
|
||||
|
||||
func writeJSON(path string, v any) error {
|
||||
b, err := json.MarshalIndent(v, "", " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return os.WriteFile(path, append(b, '\n'), 0o644)
|
||||
}
|
||||
|
||||
func fail(err error) {
|
||||
fmt.Fprintln(os.Stderr, err)
|
||||
os.Exit(1)
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
# Локальный стенд lab2. Образы закреплены тегом, не latest.
|
||||
# Сессии живут в Redis с AOF: рестарт контейнера не стирает ключи, volume redisdata сохраняет файл.
|
||||
# PostgreSQL — источник истины для пользователей, чатов и сообщений.
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.6
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-messenger}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
ports:
|
||||
- "127.0.0.1:5432:5432"
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
stop_grace_period: 10s
|
||||
|
||||
redis:
|
||||
image: redis:7.4.1
|
||||
# everysec — компромисс durability: потерять можно около секунды записей при внезапном kill -9,
|
||||
# обычный docker restart данные сессий сохраняет.
|
||||
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
|
||||
volumes:
|
||||
- redisdata:/data
|
||||
ports:
|
||||
- "127.0.0.1:6379:6379"
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
stop_grace_period: 10s
|
||||
|
||||
api:
|
||||
build: .
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: 8080
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
APP_ACCESS_LOG: ${APP_ACCESS_LOG:-1}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
DATABASE_URL: postgres://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-messenger}@postgres:5432/${POSTGRES_DB:-messenger}?sslmode=disable
|
||||
REDIS_URL: redis://redis:6379/0
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
stop_grace_period: 10s
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
redisdata:
|
||||
@@ -0,0 +1,9 @@
|
||||
ready_before=200
|
||||
stop redis
|
||||
ready_redis_down=503
|
||||
start redis
|
||||
ready_redis_back=200
|
||||
stop postgres
|
||||
ready_postgres_down=503
|
||||
start postgres
|
||||
ready_postgres_back=200
|
||||
@@ -0,0 +1,3 @@
|
||||
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,106 @@
|
||||
go test ./student-tests/ -v -count=1 -timeout 180s
|
||||
=== RUN TestMalformedJSONAndValidation
|
||||
api_test.go:73: → битый JSON, лишнее поле, пустой текст, чужой чат
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/users status=400 request_id=db0c2117-db67-4ab9-a699-15677c5c8e82 duration_ms=0
|
||||
api_test.go:76: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"db0c2117-db67-4ab9-a699-15677c5c8e82"}}
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/users status=400 request_id=e9462332-69fc-4af0-b565-138cdb4de77c duration_ms=0
|
||||
api_test.go:83: status=400 body={"error":{"code":"invalid_request","message":"malformed json","request_id":"e9462332-69fc-4af0-b565-138cdb4de77c"}}
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=2c9326a6-18dd-48f2-81d4-25649f6576ba duration_ms=47
|
||||
api_test.go:88: создан ok_user_3cadde8f id=651a935f-d2c3-43c1-8a41-2091d51869df
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=201 request_id=dac3bb08-334d-464b-a77e-7e0caa05da79 duration_ms=43
|
||||
api_test.go:89: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/chats status=201 request_id=d27a6905-9e2e-4401-bcde-d193fd3ffd31 duration_ms=8
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/chats/72b3d41a-2a9b-4200-89c7-04b8cf677fbd/messages status=400 request_id=1ab2e48a-039f-47b6-b10c-9db395a19c08 duration_ms=0
|
||||
api_test.go:92: status=400 body={"error":{"code":"invalid_request","message":"invalid text","request_id":"1ab2e48a-039f-47b6-b10c-9db395a19c08"}}
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=39d6f236-ef73-47ba-83cd-2b364cad2e93 duration_ms=41
|
||||
api_test.go:97: создан outsider_6da955f2 id=11dc7c58-8f82-4df6-9f21-efe30bbeca0b
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=201 request_id=83a59fc3-2092-4b62-bb99-d7c1b1bbf0d8 duration_ms=43
|
||||
api_test.go:98: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/chats/72b3d41a-2a9b-4200-89c7-04b8cf677fbd/messages status=404 request_id=d010a434-6f1b-4755-af3a-e0ff70dd4977 duration_ms=2
|
||||
api_test.go:100: status=404 body={"error":{"code":"not_found","message":"object not found","request_id":"d010a434-6f1b-4755-af3a-e0ff70dd4977"}}
|
||||
api_test.go:104: ✓ валидация JSON, пустого текста и чужого чата
|
||||
--- PASS: TestMalformedJSONAndValidation (0.19s)
|
||||
=== RUN TestWrongPasswordLogoutAndIgnoredUserHeader
|
||||
api_test.go:110: → неверный пароль, Basic на бизнес-методе, X-User-Id, logout
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=94135aad-22c5-4efe-9e9c-7c186e4e882f duration_ms=41
|
||||
api_test.go:111: создан auth_user_eeb9bffa id=24709210-e37e-412a-a2c3-c6bc6d1d94a5
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=eb2ab683-800d-4e27-83f9-6babb77fb78d duration_ms=43
|
||||
api_test.go:112: создан auth_other_28c87fd6 id=7ba5a8e8-7334-4d9a-adc6-f1838016ad23
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=401 request_id=af58975d-5c3d-4105-9e75-eceb8779c0d9 duration_ms=42
|
||||
api_test.go:117: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"af58975d-5c3d-4105-9e75-eceb8779c0d9"}}
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=201 request_id=37ceb9c7-1cc0-4e5e-abf2-5b1db8619733 duration_ms=42
|
||||
api_test.go:122: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/10/14 22:42:40 method=GET path=/api/v1/users/me status=401 request_id=03c49eb3-a35e-4c83-b8ea-3d18810ec773 duration_ms=0
|
||||
api_test.go:126: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"03c49eb3-a35e-4c83-b8ea-3d18810ec773"}}
|
||||
2026/10/14 22:42:40 method=GET path=/api/v1/users/me status=401 request_id=55a150d9-208a-4347-a930-4ff11c5233eb duration_ms=0
|
||||
api_test.go:132: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"55a150d9-208a-4347-a930-4ff11c5233eb"}}
|
||||
2026/10/14 22:42:40 method=GET path=/api/v1/users/me status=200 request_id=70af7739-36a1-4877-a66a-dbb6363f0218 duration_ms=1
|
||||
api_test.go:141: status=200 body={"created_at":"2026-10-14T19:42:40.597Z","display_name":"Студент","id":"24709210-e37e-412a-a2c3-c6bc6d1d94a5","username":"auth_user_eeb9bffa"}
|
||||
2026/10/14 22:42:40 method=DELETE path=/api/v1/auth/sessions/current status=204 request_id=6d8a5397-9d10-4b99-867c-ac14aceac351 duration_ms=1
|
||||
api_test.go:147: logout status=204
|
||||
2026/10/14 22:42:40 method=GET path=/api/v1/users/me status=401 request_id=c50a007a-5035-4e06-ab4a-af010d47f8c3 duration_ms=1
|
||||
2026/10/14 22:42:40 method=DELETE path=/api/v1/auth/sessions/current status=401 request_id=1c274613-aeb3-4378-a750-cc94bd18bee6 duration_ms=1
|
||||
api_test.go:159: ✓ пароль, заголовки и отзыв сессии
|
||||
--- PASS: TestWrongPasswordLogoutAndIgnoredUserHeader (0.18s)
|
||||
=== RUN TestSessionExpiry
|
||||
api_test.go:165: → SESSION_TTL=2s: тот же токен после паузы должен стать 401, TTL рестартом API не продлевается
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/users status=201 request_id=74b3345f-dec8-407a-80d9-278a1df89319 duration_ms=44
|
||||
api_test.go:166: создан ttl_user_6308467a id=be7334ea-1153-41f9-8047-1365cac6f5e4
|
||||
2026/10/14 22:42:40 method=POST path=/api/v1/auth/sessions status=201 request_id=dca5d965-9d6d-4615-bfc3-cbb2072da796 duration_ms=43
|
||||
api_test.go:167: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/10/14 22:42:43 method=GET path=/api/v1/users/me status=401 request_id=48e0b70b-ccb6-43ad-a346-28994552a1ca duration_ms=2
|
||||
api_test.go:170: status=401 body={"error":{"code":"unauthorized","message":"authentication required","request_id":"48e0b70b-ccb6-43ad-a346-28994552a1ca"}}
|
||||
api_test.go:174: ✓ истёкшая сессия отклонена
|
||||
--- PASS: TestSessionExpiry (2.59s)
|
||||
=== RUN TestDuplicateUsernameRace
|
||||
api_test.go:181: → 8 параллельных регистраций username=race_c93a2ca7
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=201 request_id=55b47bef-3dbf-40b6-ae97-54baf81e83f5 duration_ms=69
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=5e44a96e-1029-417c-9e3b-64f89d848e0b duration_ms=71
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=889d648a-012e-45c9-844d-222238746315 duration_ms=71
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=f90c40f9-b561-46bf-b1cd-0d9d9c210b1b duration_ms=72
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=c2a836e7-ac2f-4d7a-9cbd-a5244a9cf1b1 duration_ms=78
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=f857d038-d7af-4102-9049-215605ad1447 duration_ms=77
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=88060523-0692-4030-894a-3ef49ec98a3c duration_ms=80
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=409 request_id=65d31b3a-04c9-40b4-9972-9599633b56e0 duration_ms=88
|
||||
api_test.go:206: created=1 conflict=7
|
||||
api_test.go:210: ✓ UNIQUE username выдержал гонку
|
||||
--- PASS: TestDuplicateUsernameRace (0.10s)
|
||||
=== RUN TestChatCreateRollsBack
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=201 request_id=31a99df2-1cbb-4f6d-a0da-93874734b125 duration_ms=46
|
||||
api_test.go:216: создан roll_user_5dc7e0b5 id=b3e79e6a-0372-4ddb-b42b-88faf144cffa
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/auth/sessions status=201 request_id=7df88d52-ca91-4117-b0d8-e67873c30a8e duration_ms=47
|
||||
api_test.go:217: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
api_test.go:220: → создание чата с несуществующим участником должно откатиться, title=rollback-c249f42e-7e4b-45e5-899f-fca7fb2c8748
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/chats status=400 request_id=f5e498dd-c82e-449a-beba-a95a8d7bd4f2 duration_ms=7
|
||||
api_test.go:223: status=400 body={"error":{"code":"invalid_request","message":"unknown member","request_id":"f5e498dd-c82e-449a-beba-a95a8d7bd4f2"}}
|
||||
api_test.go:231: строк chats с этим title после ошибки: 0
|
||||
api_test.go:235: ✓ транзакция создания чата откатилась
|
||||
--- PASS: TestChatCreateRollsBack (0.11s)
|
||||
=== RUN TestPaginationPages
|
||||
api_test.go:241: → три сообщения, две страницы limit=2, затем последняя
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=201 request_id=5c1c6082-a8cd-4b01-99b2-160271bbce01 duration_ms=49
|
||||
api_test.go:242: создан page_user_89c36669 id=d89903f6-8866-43f7-b83d-c119cf945dc9
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/auth/sessions status=201 request_id=4ff6d887-e45d-47f8-8781-b2a8bf302dd6 duration_ms=46
|
||||
api_test.go:243: сессия выпущена, длина токена=64 (значение не печатаем)
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/chats status=201 request_id=e2552d9a-60ee-4b51-a7a8-541195f8c154 duration_ms=5
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=201 request_id=3de7ef09-36db-4d9f-8f76-ed4e4895a661 duration_ms=5
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=201 request_id=6461472e-b6c9-4c79-a676-807dbfac8e64 duration_ms=1
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=201 request_id=57164ec9-1914-489a-809d-b8dd483fd833 duration_ms=1
|
||||
2026/10/14 22:42:43 method=GET path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=200 request_id=48fea270-e7bf-4f0c-b123-bce8eec0b836 duration_ms=2
|
||||
api_test.go:253: status=200 body={"items":[{"chat_id":"0049a8b1-72ff-4d15-935c-7630c261f0d3","created_at":"2026-10-14T19:42:43.639Z","id":"ba4c7ac6-44f6-49da-9e93-dd6fc85c8bcb","sender_id":"d89903f6-8866-43f7-b83d-c119cf945dc9","text":"раз"},{"chat_id":"0049a8b1-72ff-4d15-935c-7630c261f0d3","created_at":"2026-10-14T19:42:43.643Z","id":"43302df0-2a23-4e84-929b-559d2d47ada1","sender_id":"d89903f6-8866-43f7-b83d-c119cf945dc9","te...
|
||||
2026/10/14 22:42:43 method=GET path=/api/v1/chats/0049a8b1-72ff-4d15-935c-7630c261f0d3/messages status=200 request_id=1277752d-bba6-4458-b304-9db0a01e6513 duration_ms=2
|
||||
api_test.go:261: status=200 body={"items":[{"chat_id":"0049a8b1-72ff-4d15-935c-7630c261f0d3","created_at":"2026-10-14T19:42:43.645Z","id":"187eb4f4-1ccf-4253-9737-3ec8ffbab89e","sender_id":"d89903f6-8866-43f7-b83d-c119cf945dc9","text":"три"}],"next_cursor":null}
|
||||
api_test.go:267: ✓ keyset обошёл историю без зависания cursor
|
||||
--- PASS: TestPaginationPages (0.12s)
|
||||
=== RUN TestRedisDownIsNotAnonymous
|
||||
api_test.go:271: → закрытый клиент Redis: вход и Bearer дают 503, а не 200 от анонима
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/users status=201 request_id=6d30a90b-f1f4-4952-b7f9-356316ed7bf0 duration_ms=46
|
||||
api_test.go:283: создан redis_down_64e13e26 id=2263b741-9519-489e-8d91-fe23cd9ff347
|
||||
2026/10/14 22:42:43 method=POST path=/api/v1/auth/sessions status=503 request_id=5dd380b7-9f8a-4bb9-b199-56373bedd5a6 duration_ms=44
|
||||
api_test.go:288: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"5dd380b7-9f8a-4bb9-b199-56373bedd5a6"}}
|
||||
2026/10/14 22:42:43 method=GET path=/api/v1/users/me status=503 request_id=fc700303-3f23-499c-bf31-41330924d33b duration_ms=0
|
||||
api_test.go:295: status=503 body={"error":{"code":"unavailable","message":"dependency unavailable","request_id":"fc700303-3f23-499c-bf31-41330924d33b"}}
|
||||
api_test.go:299: ✓ сбой Redis не стал анонимным доступом
|
||||
--- PASS: TestRedisDownIsNotAnonymous (0.10s)
|
||||
PASS
|
||||
ok mtusi2026lab2/student-tests 4.097s
|
||||
@@ -0,0 +1,77 @@
|
||||
{
|
||||
"explain": [
|
||||
{
|
||||
"Execution Time": 0.091,
|
||||
"Plan": {
|
||||
"Actual Loops": 1,
|
||||
"Actual Rows": 50,
|
||||
"Actual Startup Time": 0.061,
|
||||
"Actual Total Time": 0.075,
|
||||
"Async Capable": false,
|
||||
"Local Dirtied Blocks": 0,
|
||||
"Local Hit Blocks": 0,
|
||||
"Local Read Blocks": 0,
|
||||
"Local Written Blocks": 0,
|
||||
"Node Type": "Limit",
|
||||
"Parallel Aware": false,
|
||||
"Plan Rows": 50,
|
||||
"Plan Width": 24,
|
||||
"Plans": [
|
||||
{
|
||||
"Actual Loops": 1,
|
||||
"Actual Rows": 50,
|
||||
"Actual Startup Time": 0.06,
|
||||
"Actual Total Time": 0.068,
|
||||
"Alias": "messages",
|
||||
"Async Capable": false,
|
||||
"Heap Fetches": 50,
|
||||
"Index Cond": "((chat_id = 'dd159fd8-b79e-4a15-a48c-4a84bd479430'::uuid) AND (ROW(created_at, id) \u003e ROW('2026-10-14 19:46:28.256+00'::timestamp with time zone, 'f051734d-6f81-440a-9253-0b417ccee2b1'::uuid)))",
|
||||
"Index Name": "messages_history_idx",
|
||||
"Local Dirtied Blocks": 0,
|
||||
"Local Hit Blocks": 0,
|
||||
"Local Read Blocks": 0,
|
||||
"Local Written Blocks": 0,
|
||||
"Node Type": "Index Only Scan",
|
||||
"Parallel Aware": false,
|
||||
"Parent Relationship": "Outer",
|
||||
"Plan Rows": 167,
|
||||
"Plan Width": 24,
|
||||
"Relation Name": "messages",
|
||||
"Rows Removed by Index Recheck": 0,
|
||||
"Scan Direction": "Forward",
|
||||
"Shared Dirtied Blocks": 0,
|
||||
"Shared Hit Blocks": 1,
|
||||
"Shared Read Blocks": 3,
|
||||
"Shared Written Blocks": 0,
|
||||
"Startup Cost": 0.42,
|
||||
"Temp Read Blocks": 0,
|
||||
"Temp Written Blocks": 0,
|
||||
"Total Cost": 635.76
|
||||
}
|
||||
],
|
||||
"Shared Dirtied Blocks": 0,
|
||||
"Shared Hit Blocks": 1,
|
||||
"Shared Read Blocks": 3,
|
||||
"Shared Written Blocks": 0,
|
||||
"Startup Cost": 0.42,
|
||||
"Temp Read Blocks": 0,
|
||||
"Temp Written Blocks": 0,
|
||||
"Total Cost": 190.64
|
||||
},
|
||||
"Planning": {
|
||||
"Local Dirtied Blocks": 0,
|
||||
"Local Hit Blocks": 0,
|
||||
"Local Read Blocks": 0,
|
||||
"Local Written Blocks": 0,
|
||||
"Shared Dirtied Blocks": 0,
|
||||
"Shared Hit Blocks": 22,
|
||||
"Shared Read Blocks": 1,
|
||||
"Shared Written Blocks": 0,
|
||||
"Temp Read Blocks": 0,
|
||||
"Temp Written Blocks": 0
|
||||
},
|
||||
"Planning Time": 0.17,
|
||||
"Triggers": []
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,139 @@
|
||||
{
|
||||
"explain": [
|
||||
{
|
||||
"Execution Time": 16.435,
|
||||
"Plan": {
|
||||
"Actual Loops": 1,
|
||||
"Actual Rows": 50,
|
||||
"Actual Startup Time": 16.393,
|
||||
"Actual Total Time": 16.403,
|
||||
"Async Capable": false,
|
||||
"Local Dirtied Blocks": 0,
|
||||
"Local Hit Blocks": 0,
|
||||
"Local Read Blocks": 0,
|
||||
"Local Written Blocks": 0,
|
||||
"Node Type": "Limit",
|
||||
"Parallel Aware": false,
|
||||
"Plan Rows": 50,
|
||||
"Plan Width": 24,
|
||||
"Plans": [
|
||||
{
|
||||
"Actual Loops": 1,
|
||||
"Actual Rows": 50,
|
||||
"Actual Startup Time": 16.392,
|
||||
"Actual Total Time": 16.396,
|
||||
"Async Capable": false,
|
||||
"Local Dirtied Blocks": 0,
|
||||
"Local Hit Blocks": 0,
|
||||
"Local Read Blocks": 0,
|
||||
"Local Written Blocks": 0,
|
||||
"Node Type": "Sort",
|
||||
"Parallel Aware": false,
|
||||
"Parent Relationship": "Outer",
|
||||
"Plan Rows": 167,
|
||||
"Plan Width": 24,
|
||||
"Plans": [
|
||||
{
|
||||
"Actual Loops": 1,
|
||||
"Actual Rows": 44448,
|
||||
"Actual Startup Time": 4.156,
|
||||
"Actual Total Time": 10.771,
|
||||
"Alias": "messages",
|
||||
"Async Capable": false,
|
||||
"Exact Heap Blocks": 847,
|
||||
"Filter": "(ROW(created_at, id) \u003e ROW('2026-10-14 19:46:28.256+00'::timestamp with time zone, 'f051734d-6f81-440a-9253-0b417ccee2b1'::uuid))",
|
||||
"Local Dirtied Blocks": 0,
|
||||
"Local Hit Blocks": 0,
|
||||
"Local Read Blocks": 0,
|
||||
"Local Written Blocks": 0,
|
||||
"Lossy Heap Blocks": 0,
|
||||
"Node Type": "Bitmap Heap Scan",
|
||||
"Parallel Aware": false,
|
||||
"Parent Relationship": "Outer",
|
||||
"Plan Rows": 167,
|
||||
"Plan Width": 24,
|
||||
"Plans": [
|
||||
{
|
||||
"Actual Loops": 1,
|
||||
"Actual Rows": 74449,
|
||||
"Actual Startup Time": 1.682,
|
||||
"Actual Total Time": 1.683,
|
||||
"Async Capable": false,
|
||||
"Index Cond": "(chat_id = 'dd159fd8-b79e-4a15-a48c-4a84bd479430'::uuid)",
|
||||
"Index Name": "messages_chat_only_idx",
|
||||
"Local Dirtied Blocks": 0,
|
||||
"Local Hit Blocks": 0,
|
||||
"Local Read Blocks": 0,
|
||||
"Local Written Blocks": 0,
|
||||
"Node Type": "Bitmap Index Scan",
|
||||
"Parallel Aware": false,
|
||||
"Parent Relationship": "Outer",
|
||||
"Plan Rows": 500,
|
||||
"Plan Width": 0,
|
||||
"Shared Dirtied Blocks": 0,
|
||||
"Shared Hit Blocks": 0,
|
||||
"Shared Read Blocks": 66,
|
||||
"Shared Written Blocks": 0,
|
||||
"Startup Cost": 0,
|
||||
"Temp Read Blocks": 0,
|
||||
"Temp Written Blocks": 0,
|
||||
"Total Cost": 8.04
|
||||
}
|
||||
],
|
||||
"Recheck Cond": "(chat_id = 'dd159fd8-b79e-4a15-a48c-4a84bd479430'::uuid)",
|
||||
"Relation Name": "messages",
|
||||
"Rows Removed by Filter": 30001,
|
||||
"Rows Removed by Index Recheck": 0,
|
||||
"Shared Dirtied Blocks": 0,
|
||||
"Shared Hit Blocks": 847,
|
||||
"Shared Read Blocks": 66,
|
||||
"Shared Written Blocks": 0,
|
||||
"Startup Cost": 8.08,
|
||||
"Temp Read Blocks": 0,
|
||||
"Temp Written Blocks": 0,
|
||||
"Total Cost": 918.22
|
||||
}
|
||||
],
|
||||
"Shared Dirtied Blocks": 0,
|
||||
"Shared Hit Blocks": 847,
|
||||
"Shared Read Blocks": 66,
|
||||
"Shared Written Blocks": 0,
|
||||
"Sort Key": [
|
||||
"created_at",
|
||||
"id"
|
||||
],
|
||||
"Sort Method": "top-N heapsort",
|
||||
"Sort Space Type": "Memory",
|
||||
"Sort Space Used": 28,
|
||||
"Startup Cost": 923.77,
|
||||
"Temp Read Blocks": 0,
|
||||
"Temp Written Blocks": 0,
|
||||
"Total Cost": 924.19
|
||||
}
|
||||
],
|
||||
"Shared Dirtied Blocks": 0,
|
||||
"Shared Hit Blocks": 847,
|
||||
"Shared Read Blocks": 66,
|
||||
"Shared Written Blocks": 0,
|
||||
"Startup Cost": 923.77,
|
||||
"Temp Read Blocks": 0,
|
||||
"Temp Written Blocks": 0,
|
||||
"Total Cost": 923.89
|
||||
},
|
||||
"Planning": {
|
||||
"Local Dirtied Blocks": 0,
|
||||
"Local Hit Blocks": 0,
|
||||
"Local Read Blocks": 0,
|
||||
"Local Written Blocks": 0,
|
||||
"Shared Dirtied Blocks": 0,
|
||||
"Shared Hit Blocks": 16,
|
||||
"Shared Read Blocks": 1,
|
||||
"Shared Written Blocks": 0,
|
||||
"Temp Read Blocks": 0,
|
||||
"Temp Written Blocks": 0
|
||||
},
|
||||
"Planning Time": 0.131,
|
||||
"Triggers": []
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"checksum_match": true,
|
||||
"counts_match": true,
|
||||
"first_id_match": true,
|
||||
"restore_chats": 6,
|
||||
"restore_first_id": "4f8212c8-fea5-4870-989c-b5edf0dfdcf5",
|
||||
"restore_messages": 100000,
|
||||
"restore_sha256": "a6cec9d9dbd5898032730f587fdd6fad981f64360584ccfe6da60384b87e28c9",
|
||||
"source_chats": 6,
|
||||
"source_first_id": "4f8212c8-fea5-4870-989c-b5edf0dfdcf5",
|
||||
"source_messages": 100000,
|
||||
"source_sha256": "a6cec9d9dbd5898032730f587fdd6fad981f64360584ccfe6da60384b87e28c9"
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
prepared messages=100000 chats=6
|
||||
weak: node=Limit execution_ms=16.435 shared_hit_blocks=847 sort=true
|
||||
strong: node=Limit execution_ms=0.091 shared_hit_blocks=1 sort=false
|
||||
write: only_chat_id_index_ms=30 chat_id_plus_history_ms=31 rows=5000
|
||||
restore match counts=true checksum=true messages=100000
|
||||
@@ -0,0 +1,13 @@
|
||||
{
|
||||
"cursor_offset": 30000,
|
||||
"largest_chat_messages": 74449,
|
||||
"strong_index": "messages_history_idx (chat_id, created_at, id)",
|
||||
"strong_plan": "node=Limit execution_ms=0.091 shared_hit_blocks=1 sort=false",
|
||||
"weak_index": "messages_chat_only_idx (chat_id)",
|
||||
"weak_plan": "node=Limit execution_ms=16.435 shared_hit_blocks=847 sort=true",
|
||||
"write_cost": {
|
||||
"chat_id_plus_history_ms": 31,
|
||||
"only_chat_id_index_ms": 30,
|
||||
"rows": 5000
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
module mtusi2026lab2
|
||||
|
||||
go 1.23.0
|
||||
|
||||
require (
|
||||
github.com/google/uuid v1.6.0
|
||||
github.com/jackc/pgx/v5 v5.7.4
|
||||
github.com/redis/go-redis/v9 v9.7.3
|
||||
golang.org/x/crypto v0.36.0
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/cespare/xxhash/v2 v2.2.0 // indirect
|
||||
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // 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
|
||||
golang.org/x/sync v0.12.0 // indirect
|
||||
golang.org/x/sys v0.31.0 // indirect
|
||||
golang.org/x/text v0.23.0 // indirect
|
||||
)
|
||||
@@ -0,0 +1,42 @@
|
||||
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
|
||||
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
|
||||
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
|
||||
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
|
||||
github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
|
||||
github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
|
||||
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/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
|
||||
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
|
||||
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
|
||||
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
|
||||
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||
github.com/jackc/pgx/v5 v5.7.4 h1:9wKznZrhWa2QiHL+NjTSPP6yjl3451BX3imWDnokYlg=
|
||||
github.com/jackc/pgx/v5 v5.7.4/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
|
||||
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
|
||||
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||
github.com/redis/go-redis/v9 v9.7.3 h1:YpPyAayJV+XErNsatSElgRZZVCwXX9QzkKYNvO7x0wM=
|
||||
github.com/redis/go-redis/v9 v9.7.3/go.mod h1:bGUrSggJ9X9GUmZpZNEOQKaANxSGgOEBRltRTZHSvrA=
|
||||
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
|
||||
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
|
||||
golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
|
||||
golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
|
||||
golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
|
||||
golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
|
||||
golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
|
||||
golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
|
||||
golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
|
||||
golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
|
||||
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=
|
||||
@@ -0,0 +1,630 @@
|
||||
// Package api — HTTP-слой lab2.
|
||||
//
|
||||
// Порядок обработки запроса:
|
||||
// 1. X-Request-Id на каждый ответ, включая ошибки;
|
||||
// 2. журнал method/path/status без текста сообщений и без токена;
|
||||
// 3. маршрут;
|
||||
// 4. для защищённых маршрутов — только Bearer. Basic и X-User-Id доступ не дают.
|
||||
//
|
||||
// /health/live отвечает, пока процесс жив. /health/ready ещё проверяет PostgreSQL и Redis:
|
||||
// без них нельзя честно принять запись или узнать, кто делает запрос.
|
||||
package api
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026lab2/internal/session"
|
||||
"mtusi2026lab2/internal/store"
|
||||
)
|
||||
|
||||
type ctxKey int
|
||||
|
||||
const (
|
||||
userKey ctxKey = iota
|
||||
tokenKey
|
||||
requestIDKey
|
||||
)
|
||||
|
||||
const (
|
||||
challengeBasic = `Basic realm="messenger", charset="UTF-8"`
|
||||
challengeBearer = `Bearer realm="messenger"`
|
||||
)
|
||||
|
||||
// Server связывает HTTP с PostgreSQL и Redis.
|
||||
type Server struct {
|
||||
Store *store.Store
|
||||
Sessions *session.Store
|
||||
ready atomic.Bool
|
||||
}
|
||||
|
||||
// New помечает процесс готовым. Реальная зависимость всё равно проверяется в /health/ready.
|
||||
func New(st *store.Store, sessions *session.Store) *Server {
|
||||
s := &Server{Store: st, Sessions: sessions}
|
||||
s.ready.Store(true)
|
||||
return s
|
||||
}
|
||||
|
||||
// BeginDrain вызывается на SIGTERM: новые клиенты видят 503 на /health/ready.
|
||||
func (s *Server) BeginDrain() { s.ready.Store(false) }
|
||||
|
||||
// Handler собирает маршруты lab2. Идемпотентности и вложений здесь нет — это lab3+.
|
||||
func (s *Server) Handler() http.Handler {
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("GET /health/live", s.handleLive)
|
||||
mux.HandleFunc("GET /health/ready", s.handleReady)
|
||||
mux.HandleFunc("POST /api/v1/users", s.handleCreateUser)
|
||||
mux.HandleFunc("POST /api/v1/auth/sessions", s.handleCreateSession)
|
||||
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", s.requireUser(s.handleRevokeSession))
|
||||
mux.HandleFunc("GET /api/v1/users/me", s.requireUser(s.handleMe))
|
||||
mux.HandleFunc("POST /api/v1/chats", s.requireUser(s.handleCreateChat))
|
||||
mux.HandleFunc("GET /api/v1/chats", s.requireUser(s.handleListChats))
|
||||
mux.HandleFunc("GET /api/v1/chats/{chat_id}", s.requireUser(s.handleGetChat))
|
||||
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleCreateMessage))
|
||||
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", s.requireUser(s.handleListMessages))
|
||||
return s.withRequestID(s.withAccessLog(mux))
|
||||
}
|
||||
|
||||
func (s *Server) handleLive(w http.ResponseWriter, r *http.Request) {
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (s *Server) handleReady(w http.ResponseWriter, r *http.Request) {
|
||||
if !s.ready.Load() {
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "service is shutting down")
|
||||
return
|
||||
}
|
||||
if err := s.Store.Ping(r.Context()); err != nil || s.Sessions.Ping(r.Context()) != nil {
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateUser(w http.ResponseWriter, r *http.Request) {
|
||||
var body struct {
|
||||
Username string `json:"username"`
|
||||
DisplayName string `json:"display_name"`
|
||||
Password string `json:"password"`
|
||||
}
|
||||
if err := decodeStrict(r, &body); err != nil {
|
||||
writeDecodeErr(w, r, err)
|
||||
return
|
||||
}
|
||||
if !validUsername(body.Username) {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid username")
|
||||
return
|
||||
}
|
||||
display := strings.TrimSpace(body.DisplayName)
|
||||
if display == "" || utf8.RuneCountInString(display) > 100 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid display_name")
|
||||
return
|
||||
}
|
||||
if n := utf8.RuneCountInString(body.Password); n < 12 || n > 128 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid password")
|
||||
return
|
||||
}
|
||||
u, err := s.Store.CreateUser(r.Context(), body.Username, display, body.Password)
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusConflict, "conflict", "username already taken")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, userDTO(u))
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateSession(w http.ResponseWriter, r *http.Request) {
|
||||
username, password, ok := parseBasic(r.Header.Get("Authorization"))
|
||||
if !ok || !validUsername(username) {
|
||||
writeAuthError(w, r, challengeBasic)
|
||||
return
|
||||
}
|
||||
if n := utf8.RuneCountInString(password); n < 12 || n > 128 {
|
||||
writeAuthError(w, r, challengeBasic)
|
||||
return
|
||||
}
|
||||
u, err := s.Store.Authenticate(r.Context(), username, password)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeAuthError(w, r, challengeBasic)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, 0, "", "")
|
||||
return
|
||||
}
|
||||
token, exp, err := s.Sessions.Issue(r.Context(), u.ID)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, map[string]any{
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": formatTime(exp),
|
||||
"user": userDTO(u),
|
||||
})
|
||||
}
|
||||
|
||||
func (s *Server) handleRevokeSession(w http.ResponseWriter, r *http.Request) {
|
||||
token, _ := r.Context().Value(tokenKey).(string)
|
||||
if err := s.Sessions.Revoke(r.Context(), token); err != nil {
|
||||
if errors.Is(err, session.ErrUnauthorized) {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusNoContent)
|
||||
}
|
||||
|
||||
func (s *Server) handleMe(w http.ResponseWriter, r *http.Request) {
|
||||
u, err := s.Store.GetUser(r.Context(), userFrom(r))
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusUnauthorized, "unauthorized", "authentication required")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, userDTO(u))
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateChat(w http.ResponseWriter, r *http.Request) {
|
||||
var body struct {
|
||||
Title string `json:"title"`
|
||||
MemberIDs []string `json:"member_ids"`
|
||||
}
|
||||
if err := decodeStrict(r, &body); err != nil {
|
||||
writeDecodeErr(w, r, err)
|
||||
return
|
||||
}
|
||||
title := strings.TrimSpace(body.Title)
|
||||
if title == "" || utf8.RuneCountInString(title) > 100 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid title")
|
||||
return
|
||||
}
|
||||
if len(body.MemberIDs) < 1 || len(body.MemberIDs) > 100 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member_ids")
|
||||
return
|
||||
}
|
||||
uid := userFrom(r)
|
||||
seen := make(map[uuid.UUID]struct{}, len(body.MemberIDs))
|
||||
ids := make([]uuid.UUID, 0, len(body.MemberIDs))
|
||||
callerPresent := false
|
||||
for _, raw := range body.MemberIDs {
|
||||
id, err := uuid.Parse(raw)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid member id")
|
||||
return
|
||||
}
|
||||
if _, dup := seen[id]; dup {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "duplicate member id")
|
||||
return
|
||||
}
|
||||
seen[id] = struct{}{}
|
||||
if id == uid {
|
||||
callerPresent = true
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
if !callerPresent {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "caller must be a member")
|
||||
return
|
||||
}
|
||||
chat, err := s.Store.CreateChat(r.Context(), title, ids)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "unknown member")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, 0, "", "")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, chatDTO(chat))
|
||||
}
|
||||
|
||||
func (s *Server) handleListChats(w http.ResponseWriter, r *http.Request) {
|
||||
uid := userFrom(r)
|
||||
limit, after, err := parsePage(r, "chats:"+uid.String())
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
|
||||
return
|
||||
}
|
||||
items, next, err := s.Store.ListChats(r.Context(), uid, limit, after)
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||||
return
|
||||
}
|
||||
out := make([]any, len(items))
|
||||
for i := range items {
|
||||
out[i] = chatDTO(&items[i])
|
||||
}
|
||||
var cursor *store.PageCursor
|
||||
if next != nil {
|
||||
cursor = &store.PageCursor{Scope: "chats:" + uid.String(), CreatedAt: next.CreatedAt, ID: next.ID}
|
||||
}
|
||||
writeJSON(w, http.StatusOK, pageDTO(out, cursor))
|
||||
}
|
||||
|
||||
func (s *Server) handleGetChat(w http.ResponseWriter, r *http.Request) {
|
||||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||||
return
|
||||
}
|
||||
chat, err := s.Store.GetChat(r.Context(), chatID, userFrom(r))
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, 0, "", "")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, chatDTO(chat))
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateMessage(w http.ResponseWriter, r *http.Request) {
|
||||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||||
return
|
||||
}
|
||||
var body struct {
|
||||
Text string `json:"text"`
|
||||
}
|
||||
if err := decodeStrict(r, &body); err != nil {
|
||||
writeDecodeErr(w, r, err)
|
||||
return
|
||||
}
|
||||
text := strings.TrimSpace(body.Text)
|
||||
if text == "" || utf8.RuneCountInString(text) > 4000 {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid text")
|
||||
return
|
||||
}
|
||||
msg, err := s.Store.CreateMessage(r.Context(), chatID, userFrom(r), text)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, 0, "", "")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusCreated, messageDTO(msg))
|
||||
}
|
||||
|
||||
func (s *Server) handleListMessages(w http.ResponseWriter, r *http.Request) {
|
||||
chatID, err := uuid.Parse(r.PathValue("chat_id"))
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid chat id")
|
||||
return
|
||||
}
|
||||
scope := "chat:" + chatID.String()
|
||||
limit, after, err := parsePage(r, scope)
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", err.Error())
|
||||
return
|
||||
}
|
||||
items, next, err := s.Store.ListMessages(r.Context(), chatID, userFrom(r), limit, after)
|
||||
if errors.Is(err, store.ErrNotFound) {
|
||||
writeError(w, r, http.StatusNotFound, "not_found", "object not found")
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
s.writeStoreErr(w, r, err, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||||
return
|
||||
}
|
||||
out := make([]any, len(items))
|
||||
for i := range items {
|
||||
out[i] = messageDTO(&items[i])
|
||||
}
|
||||
var cursor *store.PageCursor
|
||||
if next != nil {
|
||||
cursor = &store.PageCursor{Scope: scope, CreatedAt: next.CreatedAt, ID: next.ID}
|
||||
}
|
||||
writeJSON(w, http.StatusOK, pageDTO(out, cursor))
|
||||
}
|
||||
|
||||
// requireUser принимает только Authorization: Bearer. X-User-Id не читается.
|
||||
// Basic на бизнес-методе — тот же 401, но с Bearer-challenge, не с Basic.
|
||||
func (s *Server) requireUser(next http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
header := r.Header.Get("Authorization")
|
||||
if strings.HasPrefix(strings.ToLower(header), "basic ") {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
token, ok := parseBearer(header)
|
||||
if !ok {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
uid, err := s.Sessions.Lookup(r.Context(), token)
|
||||
if errors.Is(err, session.ErrUnauthorized) {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
return
|
||||
}
|
||||
ctx := context.WithValue(r.Context(), userKey, uid)
|
||||
ctx = context.WithValue(ctx, tokenKey, token)
|
||||
next(w, r.WithContext(ctx))
|
||||
}
|
||||
}
|
||||
|
||||
func userFrom(r *http.Request) uuid.UUID {
|
||||
id, _ := r.Context().Value(userKey).(uuid.UUID)
|
||||
return id
|
||||
}
|
||||
|
||||
func (s *Server) withRequestID(next http.Handler) http.Handler {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
rid := r.Header.Get("X-Request-Id")
|
||||
if rid == "" {
|
||||
rid = uuid.NewString()
|
||||
}
|
||||
w.Header().Set("X-Request-Id", rid)
|
||||
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), requestIDKey, rid)))
|
||||
})
|
||||
}
|
||||
|
||||
type statusRecorder struct {
|
||||
http.ResponseWriter
|
||||
status int
|
||||
}
|
||||
|
||||
func (s *statusRecorder) WriteHeader(code int) {
|
||||
s.status = code
|
||||
s.ResponseWriter.WriteHeader(code)
|
||||
}
|
||||
|
||||
func (s *Server) withAccessLog(next http.Handler) http.Handler {
|
||||
quiet := strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "0") || strings.EqualFold(os.Getenv("APP_ACCESS_LOG"), "false")
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
start := time.Now()
|
||||
rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
|
||||
next.ServeHTTP(rec, r)
|
||||
if quiet && rec.status < 400 {
|
||||
return
|
||||
}
|
||||
if strings.HasPrefix(r.URL.Path, "/health/") && rec.status == http.StatusOK {
|
||||
return
|
||||
}
|
||||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||||
// path без query: в cursor нет секрета, но и текста сообщения в логе быть не должно.
|
||||
log.Printf("method=%s path=%s status=%d request_id=%s duration_ms=%d",
|
||||
r.Method, r.URL.Path, rec.status, rid, time.Since(start).Milliseconds())
|
||||
})
|
||||
}
|
||||
|
||||
func parsePage(r *http.Request, expectedScope string) (int, *store.PageCursor, error) {
|
||||
limit := 50
|
||||
if raw := r.URL.Query().Get("limit"); raw != "" {
|
||||
n, err := strconv.Atoi(raw)
|
||||
if err != nil || n < 1 || n > 100 {
|
||||
return 0, nil, fmt.Errorf("invalid limit")
|
||||
}
|
||||
limit = n
|
||||
}
|
||||
rawCursor := r.URL.Query().Get("cursor")
|
||||
if rawCursor == "" {
|
||||
return limit, nil, nil
|
||||
}
|
||||
cur, err := decodeCursor(rawCursor)
|
||||
if err != nil || cur.Scope != expectedScope {
|
||||
return 0, nil, fmt.Errorf("invalid cursor")
|
||||
}
|
||||
return limit, cur, nil
|
||||
}
|
||||
|
||||
func encodeCursor(c *store.PageCursor) string {
|
||||
payload := fmt.Sprintf("%s|%s|%s", c.Scope, c.CreatedAt.UTC().Format(time.RFC3339Nano), c.ID.String())
|
||||
return base64.RawURLEncoding.EncodeToString([]byte(payload))
|
||||
}
|
||||
|
||||
func decodeCursor(raw string) (*store.PageCursor, error) {
|
||||
b, err := base64.RawURLEncoding.DecodeString(raw)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
parts := strings.SplitN(string(b), "|", 3)
|
||||
if len(parts) != 3 {
|
||||
return nil, fmt.Errorf("bad cursor")
|
||||
}
|
||||
ts, err := time.Parse(time.RFC3339Nano, parts[1])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
id, err := uuid.Parse(parts[2])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &store.PageCursor{Scope: parts[0], CreatedAt: ts.UTC(), ID: id}, nil
|
||||
}
|
||||
|
||||
func validUsername(s string) bool {
|
||||
if len(s) < 3 || len(s) > 32 {
|
||||
return false
|
||||
}
|
||||
for _, c := range s {
|
||||
if (c < 'a' || c > 'z') && (c < '0' || c > '9') && c != '_' {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func decodeStrict(r *http.Request, dst any) error {
|
||||
ct := r.Header.Get("Content-Type")
|
||||
if ct != "" && !strings.HasPrefix(strings.ToLower(strings.TrimSpace(ct)), "application/json") {
|
||||
return errUnsupported
|
||||
}
|
||||
dec := json.NewDecoder(r.Body)
|
||||
dec.DisallowUnknownFields()
|
||||
if err := dec.Decode(dst); err != nil {
|
||||
return errMalformed
|
||||
}
|
||||
if dec.More() {
|
||||
return errMalformed
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var (
|
||||
errUnsupported = errors.New("unsupported media type")
|
||||
errMalformed = errors.New("malformed json")
|
||||
)
|
||||
|
||||
func writeDecodeErr(w http.ResponseWriter, r *http.Request, err error) {
|
||||
if errors.Is(err, errUnsupported) {
|
||||
writeError(w, r, http.StatusUnsupportedMediaType, "unsupported_media_type", "unsupported media type")
|
||||
return
|
||||
}
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "malformed json")
|
||||
}
|
||||
|
||||
func parseBasic(header string) (string, string, bool) {
|
||||
const prefix = "basic "
|
||||
if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix {
|
||||
return "", "", false
|
||||
}
|
||||
raw, err := base64.StdEncoding.DecodeString(strings.TrimSpace(header[len(prefix):]))
|
||||
if err != nil || !utf8.Valid(raw) {
|
||||
return "", "", false
|
||||
}
|
||||
user, pass, ok := strings.Cut(string(raw), ":")
|
||||
if !ok || user == "" {
|
||||
return "", "", false
|
||||
}
|
||||
return user, pass, true
|
||||
}
|
||||
|
||||
func parseBearer(header string) (string, bool) {
|
||||
const prefix = "bearer "
|
||||
if len(header) < len(prefix) || strings.ToLower(header[:len(prefix)]) != prefix {
|
||||
return "", false
|
||||
}
|
||||
token := strings.TrimSpace(header[len(prefix):])
|
||||
if token == "" || strings.Contains(token, " ") {
|
||||
return "", false
|
||||
}
|
||||
return token, true
|
||||
}
|
||||
|
||||
func userDTO(u *store.User) map[string]any {
|
||||
return map[string]any{
|
||||
"id": u.ID.String(),
|
||||
"username": u.Username,
|
||||
"display_name": u.DisplayName,
|
||||
"created_at": formatTime(u.CreatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func chatDTO(c *store.Chat) map[string]any {
|
||||
ids := make([]string, len(c.MemberIDs))
|
||||
for i, id := range c.MemberIDs {
|
||||
ids[i] = id.String()
|
||||
}
|
||||
return map[string]any{
|
||||
"id": c.ID.String(),
|
||||
"title": c.Title,
|
||||
"member_ids": ids,
|
||||
"created_at": formatTime(c.CreatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func messageDTO(m *store.Message) map[string]any {
|
||||
return map[string]any{
|
||||
"id": m.ID.String(),
|
||||
"chat_id": m.ChatID.String(),
|
||||
"sender_id": m.SenderID.String(),
|
||||
"text": m.Text,
|
||||
"created_at": formatTime(m.CreatedAt),
|
||||
}
|
||||
}
|
||||
|
||||
func pageDTO(items []any, next *store.PageCursor) map[string]any {
|
||||
var cursor any
|
||||
if next != nil {
|
||||
cursor = encodeCursor(next)
|
||||
}
|
||||
if items == nil {
|
||||
items = []any{}
|
||||
}
|
||||
return map[string]any{"items": items, "next_cursor": cursor}
|
||||
}
|
||||
|
||||
func formatTime(t time.Time) string {
|
||||
return t.UTC().Truncate(time.Millisecond).Format("2006-01-02T15:04:05.000Z")
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
enc := json.NewEncoder(w)
|
||||
enc.SetEscapeHTML(false)
|
||||
_ = enc.Encode(v)
|
||||
}
|
||||
|
||||
func writeError(w http.ResponseWriter, r *http.Request, status int, code, message string) {
|
||||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||||
if rid == "" {
|
||||
rid = w.Header().Get("X-Request-Id")
|
||||
}
|
||||
writeJSON(w, status, map[string]any{
|
||||
"error": map[string]any{
|
||||
"code": code,
|
||||
"message": message,
|
||||
"request_id": rid,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
func writeAuthError(w http.ResponseWriter, r *http.Request, challenge string) {
|
||||
w.Header().Set("WWW-Authenticate", challenge)
|
||||
writeError(w, r, http.StatusUnauthorized, "unauthorized", "authentication required")
|
||||
}
|
||||
|
||||
// writeStoreErr прячет текст драйвера. fallbackStatus используется для ожидаемой доменной ошибки.
|
||||
func (s *Server) writeStoreErr(w http.ResponseWriter, r *http.Request, err error, fallbackStatus int, fallbackCode, fallbackMessage string) {
|
||||
switch {
|
||||
case errors.Is(err, store.ErrUnavailable):
|
||||
writeError(w, r, http.StatusServiceUnavailable, "unavailable", "dependency unavailable")
|
||||
case errors.Is(err, store.ErrConflict) && fallbackStatus != 0:
|
||||
writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage)
|
||||
case errors.Is(err, store.ErrNotFound) && fallbackStatus != 0:
|
||||
if fallbackCode == "unauthorized" {
|
||||
writeAuthError(w, r, challengeBearer)
|
||||
return
|
||||
}
|
||||
writeError(w, r, fallbackStatus, fallbackCode, fallbackMessage)
|
||||
case errors.Is(err, store.ErrInvalidCursor):
|
||||
writeError(w, r, http.StatusBadRequest, "invalid_request", "invalid cursor")
|
||||
default:
|
||||
if errors.Is(err, store.ErrConflict) {
|
||||
writeError(w, r, http.StatusConflict, "conflict", "username already taken")
|
||||
return
|
||||
}
|
||||
// В лог — только тип, без SQL и без текста, который драйвер мог вложить в ошибку.
|
||||
log.Printf("request_id=%s store_error_type=%T", requestID(r), err)
|
||||
writeError(w, r, http.StatusInternalServerError, "internal_error", "internal error")
|
||||
}
|
||||
}
|
||||
|
||||
func requestID(r *http.Request) string {
|
||||
rid, _ := r.Context().Value(requestIDKey).(string)
|
||||
return rid
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
// Package auth хранит пароли через Argon2id.
|
||||
//
|
||||
// bcrypt отвергнут: библиотека молча режет пароль на 72 байта, а контракт
|
||||
// разрешает до 128 Unicode code points, включая символы вне ASCII.
|
||||
// Argon2id принимает пароль целиком. Параметры — интерактивные, не «серверные»
|
||||
// на сотни миллисекунд: smoke создаёт несколько пользователей подряд.
|
||||
package auth
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"crypto/subtle"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"golang.org/x/crypto/argon2"
|
||||
)
|
||||
|
||||
const (
|
||||
argonTime = 2
|
||||
argonMemory = 19 * 1024 // KiB, около 19 MiB
|
||||
argonThreads = 1
|
||||
argonKeyLen = 32
|
||||
argonSaltLen = 16
|
||||
)
|
||||
|
||||
// Hasher умеет хешировать и проверять. dummy — хеш случайного пароля,
|
||||
// чтобы отсутствующий username занимал примерно столько же CPU, сколько неверный пароль.
|
||||
type Hasher struct {
|
||||
dummy string
|
||||
}
|
||||
|
||||
// NewHasher готовит dummy-хеш один раз на процесс.
|
||||
func NewHasher() (*Hasher, error) {
|
||||
dummy, err := Hash(randomPassword())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &Hasher{dummy: dummy}, nil
|
||||
}
|
||||
|
||||
// Hash возвращает PHC-строку. Её пишем в users.password_hash.
|
||||
func Hash(password string) (string, error) {
|
||||
salt := make([]byte, argonSaltLen)
|
||||
if _, err := rand.Read(salt); err != nil {
|
||||
return "", err
|
||||
}
|
||||
sum := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
|
||||
return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s",
|
||||
argonMemory, argonTime, argonThreads,
|
||||
base64.RawStdEncoding.EncodeToString(salt),
|
||||
base64.RawStdEncoding.EncodeToString(sum),
|
||||
), nil
|
||||
}
|
||||
|
||||
// Verify сравнивает пароль с PHC-строкой. При битой строке возвращает false, не панику.
|
||||
func (h *Hasher) Verify(encoded, password string) bool {
|
||||
if encoded == "" {
|
||||
encoded = h.dummy
|
||||
}
|
||||
ok, err := verify(encoded, password)
|
||||
if err != nil {
|
||||
// Всё равно тратим время dummy-проверки, чтобы ветка ошибки не была мгновенной.
|
||||
_, _ = verify(h.dummy, password)
|
||||
return false
|
||||
}
|
||||
return ok
|
||||
}
|
||||
|
||||
// Burn тратит время проверки, когда пользователя нет. Результат всегда false.
|
||||
func (h *Hasher) Burn(password string) {
|
||||
_, _ = verify(h.dummy, password)
|
||||
}
|
||||
|
||||
func verify(encoded, password string) (bool, error) {
|
||||
parts := strings.Split(encoded, "$")
|
||||
// ["", "argon2id", "v=19", "m=..,t=..,p=..", salt, hash]
|
||||
if len(parts) != 6 || parts[1] != "argon2id" || parts[2] != "v=19" {
|
||||
return false, fmt.Errorf("bad hash")
|
||||
}
|
||||
var memory uint32
|
||||
var timeCost uint32
|
||||
var threads uint8
|
||||
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil {
|
||||
return false, err
|
||||
}
|
||||
if memory != argonMemory || timeCost != argonTime || threads != argonThreads {
|
||||
return false, fmt.Errorf("unexpected argon2 parameters")
|
||||
}
|
||||
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
want, err := base64.RawStdEncoding.DecodeString(parts[5])
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
got := argon2.IDKey([]byte(password), salt, timeCost, memory, threads, uint32(len(want)))
|
||||
// ConstantTimeCompare не даёт выйти на первом несовпавшем байте.
|
||||
if subtle.ConstantTimeCompare(got, want) != 1 {
|
||||
return false, nil
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func randomPassword() string {
|
||||
buf := make([]byte, 24)
|
||||
_, _ = rand.Read(buf)
|
||||
return base64.RawStdEncoding.EncodeToString(buf)
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
// Package config читает настройки процесса из окружения.
|
||||
//
|
||||
// Прямые URL (DATABASE_URL, REDIS_URL) удобны в Compose.
|
||||
// Вариант *_FILE из .env.example нужен, если секрет смонтирован файлом:
|
||||
// тогда в переменной лежит путь, а не сам секрет.
|
||||
package config
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Config — всё, что процесс обязан знать до открытия соединений.
|
||||
type Config struct {
|
||||
Host string
|
||||
Port int
|
||||
Env string
|
||||
DatabaseURL string
|
||||
RedisURL string
|
||||
SessionTTL time.Duration
|
||||
}
|
||||
|
||||
// Load собирает Config. Пустой URL без файла — ошибка запуска, а не тихий дефолт на чужой хост.
|
||||
func Load() (Config, error) {
|
||||
cfg := Config{
|
||||
Host: getenv("APP_HOST", "0.0.0.0"),
|
||||
Env: getenv("APP_ENV", "lab"),
|
||||
}
|
||||
port, err := strconv.Atoi(getenv("APP_PORT", "8080"))
|
||||
if err != nil || port < 1 || port > 65535 {
|
||||
return cfg, fmt.Errorf("invalid APP_PORT")
|
||||
}
|
||||
cfg.Port = port
|
||||
|
||||
ttlSec, err := strconv.Atoi(getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
if err != nil || ttlSec < 1 || ttlSec > 7*24*3600 {
|
||||
return cfg, fmt.Errorf("invalid SESSION_TTL_SECONDS")
|
||||
}
|
||||
cfg.SessionTTL = time.Duration(ttlSec) * time.Second
|
||||
|
||||
cfg.DatabaseURL, err = getenvOrFile("DATABASE_URL", "DATABASE_URL_FILE")
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
cfg.RedisURL, err = getenvOrFile("REDIS_URL", "CACHE_URL_FILE")
|
||||
if err != nil {
|
||||
return cfg, err
|
||||
}
|
||||
return cfg, nil
|
||||
}
|
||||
|
||||
// Addr — адрес Listen, обычно 0.0.0.0:8080 внутри контейнера.
|
||||
func (c Config) Addr() string {
|
||||
return fmt.Sprintf("%s:%d", c.Host, c.Port)
|
||||
}
|
||||
|
||||
func getenv(key, fallback string) string {
|
||||
if v := strings.TrimSpace(os.Getenv(key)); v != "" {
|
||||
return v
|
||||
}
|
||||
return fallback
|
||||
}
|
||||
|
||||
func getenvOrFile(directKey, fileKey string) (string, error) {
|
||||
if v := strings.TrimSpace(os.Getenv(directKey)); v != "" {
|
||||
return v, nil
|
||||
}
|
||||
path := strings.TrimSpace(os.Getenv(fileKey))
|
||||
if path == "" {
|
||||
return "", fmt.Errorf("set %s or %s", directKey, fileKey)
|
||||
}
|
||||
b, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("read %s: %w", fileKey, err)
|
||||
}
|
||||
v := strings.TrimSpace(string(b))
|
||||
if v == "" {
|
||||
return "", fmt.Errorf("%s is empty", fileKey)
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
// Package session хранит opaque Bearer-сессии в Redis.
|
||||
//
|
||||
// PostgreSQL остаётся источником истины для пользователей и сообщений.
|
||||
// Сессия — отдельная роль: случайный токен, срок жизни SESSION_TTL_SECONDS и отзыв.
|
||||
// В Redis лежит не сам токен, а его SHA-256: дамп AOF не содержит значение,
|
||||
// которое клиент предъявляет в Authorization.
|
||||
//
|
||||
// TTL ключа равен оставшемуся сроку сессии. Рестарт API его не продлевает.
|
||||
// Рестарт Redis сессию сохраняет только потому, что включён AOF на volume.
|
||||
package session
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrUnauthorized = errors.New("unauthorized")
|
||||
ErrUnavailable = errors.New("unavailable")
|
||||
)
|
||||
|
||||
// Store — клиент Redis с короткими таймаутами.
|
||||
type Store struct {
|
||||
client *redis.Client
|
||||
ttl time.Duration
|
||||
}
|
||||
|
||||
// Open разбирает redis:// URL. Пароль в лог не пишется.
|
||||
func Open(redisURL string, ttl time.Duration) (*Store, error) {
|
||||
opt, err := redis.ParseURL(redisURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse redis url: %w", err)
|
||||
}
|
||||
opt.DialTimeout = 500 * time.Millisecond
|
||||
opt.ReadTimeout = 500 * time.Millisecond
|
||||
opt.WriteTimeout = 500 * time.Millisecond
|
||||
opt.PoolSize = 20
|
||||
client := redis.NewClient(opt)
|
||||
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
||||
defer cancel()
|
||||
if err := client.Ping(ctx).Err(); err != nil {
|
||||
_ = client.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &Store{client: client, ttl: ttl}, nil
|
||||
}
|
||||
|
||||
// Close закрывает пул при остановке процесса.
|
||||
func (s *Store) Close() error {
|
||||
return s.client.Close()
|
||||
}
|
||||
|
||||
// Ping — готовность кэша сессий. Недоступный Redis не означает «анонимный доступ».
|
||||
func (s *Store) Ping(ctx context.Context) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 300*time.Millisecond)
|
||||
defer cancel()
|
||||
if err := s.client.Ping(ctx).Err(); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Issue выпускает 256 бит случайности (32 байта) и кладёт сессию с TTL.
|
||||
// Наружу уходит hex (64 символа). В Redis — только хеш.
|
||||
func (s *Store) Issue(ctx context.Context, userID uuid.UUID) (token string, expiresAt time.Time, err error) {
|
||||
buf := make([]byte, 32)
|
||||
if _, err = rand.Read(buf); err != nil {
|
||||
return "", time.Time{}, err
|
||||
}
|
||||
token = hex.EncodeToString(buf)
|
||||
expiresAt = time.Now().UTC().Add(s.ttl).Truncate(time.Millisecond)
|
||||
value := userID.String() + "|" + expiresAt.Format(time.RFC3339Nano)
|
||||
ctx, cancel := context.WithTimeout(ctx, time.Second)
|
||||
defer cancel()
|
||||
if err = s.client.Set(ctx, key(token), value, time.Until(expiresAt)).Err(); err != nil {
|
||||
return "", time.Time{}, ErrUnavailable
|
||||
}
|
||||
return token, expiresAt, nil
|
||||
}
|
||||
|
||||
// Lookup возвращает владельца живой сессии.
|
||||
// Промах и истёкший срок — ErrUnauthorized. Сбой Redis — ErrUnavailable (HTTP 503).
|
||||
func (s *Store) Lookup(ctx context.Context, token string) (uuid.UUID, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, time.Second)
|
||||
defer cancel()
|
||||
raw, err := s.client.Get(ctx, key(token)).Result()
|
||||
if errors.Is(err, redis.Nil) {
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
if err != nil {
|
||||
return uuid.Nil, ErrUnavailable
|
||||
}
|
||||
userPart, expPart, ok := strings.Cut(raw, "|")
|
||||
if !ok {
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
exp, err := time.Parse(time.RFC3339Nano, expPart)
|
||||
if err != nil || !exp.After(time.Now()) {
|
||||
_ = s.client.Del(ctx, key(token)).Err()
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
id, err := uuid.Parse(userPart)
|
||||
if err != nil {
|
||||
return uuid.Nil, ErrUnauthorized
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// Revoke удаляет текущую сессию. Повторный отзыв — это уже отсутствие ключа.
|
||||
func (s *Store) Revoke(ctx context.Context, token string) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, time.Second)
|
||||
defer cancel()
|
||||
n, err := s.client.Del(ctx, key(token)).Result()
|
||||
if err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
if n == 0 {
|
||||
return ErrUnauthorized
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func key(token string) string {
|
||||
sum := sha256.Sum256([]byte(token))
|
||||
return "sess:" + hex.EncodeToString(sum[:])
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"embed"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
//go:embed migrations/*.sql
|
||||
var migrationFS embed.FS
|
||||
|
||||
// Migrate применяет встроенные SQL-файлы по одному разу.
|
||||
// Повторный старт процесса не создаёт вторую копию строк: версия пишется в schema_migrations.
|
||||
func (s *Store) Migrate(ctx context.Context) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
||||
defer cancel()
|
||||
if _, err := s.pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
)`); err != nil {
|
||||
return fmt.Errorf("schema_migrations: %w", err)
|
||||
}
|
||||
entries, err := migrationFS.ReadDir("migrations")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
names := make([]string, 0, len(entries))
|
||||
for _, e := range entries {
|
||||
if !e.IsDir() && strings.HasSuffix(e.Name(), ".sql") {
|
||||
names = append(names, e.Name())
|
||||
}
|
||||
}
|
||||
sort.Strings(names)
|
||||
for _, name := range names {
|
||||
var exists bool
|
||||
if err := s.pool.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM schema_migrations WHERE version = $1)`, name).Scan(&exists); err != nil {
|
||||
return err
|
||||
}
|
||||
if exists {
|
||||
continue
|
||||
}
|
||||
body, err := migrationFS.ReadFile("migrations/" + name)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
// pgx в extended protocol не выполняет несколько команд одним Exec.
|
||||
for _, stmt := range splitSQL(string(body)) {
|
||||
if _, err := tx.Exec(ctx, stmt); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return fmt.Errorf("migrate %s: %w", name, err)
|
||||
}
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version) VALUES ($1)`, name); err != nil {
|
||||
_ = tx.Rollback(ctx)
|
||||
return err
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// splitSQL делит файл миграции по ';'. В этих файлах нет строк с точкой с запятой внутри литералов.
|
||||
func splitSQL(body string) []string {
|
||||
parts := strings.Split(body, ";")
|
||||
out := make([]string, 0, len(parts))
|
||||
for _, part := range parts {
|
||||
stmt := strings.TrimSpace(part)
|
||||
if stmt == "" {
|
||||
continue
|
||||
}
|
||||
out = append(out, stmt)
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
-- Схема lab2. PostgreSQL — источник истины для пользователей, чатов и сообщений.
|
||||
-- Сессии здесь намеренно нет: их держит Redis с AOF, TTL не продлевается рестартом API.
|
||||
-- Повторный запуск безопасен: все объекты создаются через IF NOT EXISTS.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
-- Argon2id PHC-строка. Не SHA-256 и не plaintext. Наружу не отдаётся.
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL,
|
||||
CONSTRAINT users_username_unique UNIQUE (username)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
-- Составной первичный ключ не даёт вставить участника дважды.
|
||||
-- Внешние ключи не дают сослаться на несуществующего пользователя или чат.
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
-- Список чатов пользователя начинается с фильтра «где я участник».
|
||||
CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
-- Keyset истории: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id.
|
||||
-- Составной индекс покрывает и фильтр, и порядок. Слабый индекс только по chat_id
|
||||
-- заставил бы сортировать историю чата. Его нет в продовой схеме, он появляется
|
||||
-- лишь на время эксперимента трека 2.
|
||||
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,496 @@
|
||||
// Package store — пользователи, чаты и сообщения в PostgreSQL.
|
||||
//
|
||||
// Источник истины lab2 — только эти таблицы. Память процесса после рестарта пуста,
|
||||
// поэтому ни одного map с данными здесь нет. Каждый запрос параметризован ($1, $2):
|
||||
// текст сообщения не склеивается в SQL.
|
||||
//
|
||||
// Создание чата — одна транзакция: строка чата и все участники фиксируются вместе
|
||||
// либо не фиксируются вообще. Уникальность username обеспечивает UNIQUE, а не проверка
|
||||
// «сначала SELECT, потом INSERT» (та проверка проигрывает гонке).
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"mtusi2026lab2/internal/auth"
|
||||
)
|
||||
|
||||
const queryTimeout = 3 * time.Second
|
||||
|
||||
// Ошибки домена. HTTP-слой переводит их в коды контракта и не показывает SQL.
|
||||
var (
|
||||
ErrConflict = errors.New("conflict")
|
||||
ErrNotFound = errors.New("not found")
|
||||
ErrInvalidCursor = errors.New("invalid cursor")
|
||||
ErrUnavailable = errors.New("unavailable")
|
||||
)
|
||||
|
||||
// User — публичные поля пользователя. Hash пароля в эту структуру не попадает.
|
||||
type User struct {
|
||||
ID uuid.UUID
|
||||
Username string
|
||||
DisplayName string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// Chat — чат и явный состав участников.
|
||||
type Chat struct {
|
||||
ID uuid.UUID
|
||||
Title string
|
||||
MemberIDs []uuid.UUID
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// Message — одно подтверждённое сообщение. sender_id назначает сервер.
|
||||
type Message struct {
|
||||
ID uuid.UUID
|
||||
ChatID uuid.UUID
|
||||
SenderID uuid.UUID
|
||||
Text string
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// PageCursor — позиция keyset. Клиент видит только opaque-строку в пакете api.
|
||||
type PageCursor struct {
|
||||
CreatedAt time.Time
|
||||
ID uuid.UUID
|
||||
Scope string
|
||||
}
|
||||
|
||||
// Store — пул соединений. Пул ограничен, у каждого запроса свой таймаут.
|
||||
type Store struct {
|
||||
pool *pgxpool.Pool
|
||||
hasher *auth.Hasher
|
||||
}
|
||||
|
||||
// Open поднимает пул. ConnectTimeout короткий, чтобы недоступная БД быстро стала 503,
|
||||
// а не висела до клиентского таймаута теста.
|
||||
func Open(ctx context.Context, databaseURL string, hasher *auth.Hasher) (*Store, error) {
|
||||
cfg, err := pgxpool.ParseConfig(databaseURL)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("parse database url: %w", err)
|
||||
}
|
||||
cfg.MaxConns = 10
|
||||
cfg.MinConns = 1
|
||||
cfg.MaxConnLifetime = 30 * time.Minute
|
||||
cfg.MaxConnIdleTime = 5 * time.Minute
|
||||
cfg.HealthCheckPeriod = 30 * time.Second
|
||||
cfg.ConnConfig.ConnectTimeout = 2 * time.Second
|
||||
cfg.AfterConnect = func(ctx context.Context, conn *pgx.Conn) error {
|
||||
// UTC, чтобы timestamptz читался так же, как мы его записали.
|
||||
// statement_timeout обрывает запрос, который внезапно решил сканировать всё.
|
||||
_, err := conn.Exec(ctx, `SET TIME ZONE 'UTC'; SET statement_timeout = '3s'`)
|
||||
return err
|
||||
}
|
||||
pool, err := pgxpool.NewWithConfig(ctx, cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
pingCtx, cancel := context.WithTimeout(ctx, 3*time.Second)
|
||||
defer cancel()
|
||||
if err := pool.Ping(pingCtx); err != nil {
|
||||
pool.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &Store{pool: pool, hasher: hasher}, nil
|
||||
}
|
||||
|
||||
// Close освобождает соединения при остановке процесса.
|
||||
func (s *Store) Close() {
|
||||
s.pool.Close()
|
||||
}
|
||||
|
||||
// Ping — проверка для /health/ready. Ошибка здесь значит «не готов», не «жив».
|
||||
func (s *Store) Ping(ctx context.Context) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, 300*time.Millisecond)
|
||||
defer cancel()
|
||||
if err := s.pool.Ping(ctx); err != nil {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CreateUser пишет пользователя. Повтор username → ErrConflict благодаря UNIQUE.
|
||||
func (s *Store) CreateUser(ctx context.Context, username, displayName, password string) (*User, error) {
|
||||
hash, err := auth.Hash(password)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
u := &User{
|
||||
ID: uuid.New(),
|
||||
Username: username,
|
||||
DisplayName: displayName,
|
||||
CreatedAt: nowUTC(),
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
_, err = s.pool.Exec(ctx, `
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)`,
|
||||
u.ID, u.Username, u.DisplayName, hash, u.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// Authenticate проверяет Basic-логин. Нет пользователя и неверный пароль
|
||||
// выглядят одинаково: оба дают false без отдельной ошибки «такого логина нет».
|
||||
func (s *Store) Authenticate(ctx context.Context, username, password string) (*User, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var u User
|
||||
var hash string
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT id, username, display_name, created_at, password_hash
|
||||
FROM users WHERE username = $1`, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt, &hash)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
s.hasher.Burn(password)
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if !s.hasher.Verify(hash, password) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return &u, nil
|
||||
}
|
||||
|
||||
// GetUser нужен, чтобы ответ /users/me совпал с объектом из регистрации.
|
||||
func (s *Store) GetUser(ctx context.Context, id uuid.UUID) (*User, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var u User
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT id, username, display_name, created_at FROM users WHERE id = $1`, id).
|
||||
Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return &u, nil
|
||||
}
|
||||
|
||||
// CreateChat атомарно создаёт чат и состав. Неизвестный участник откатывает всё:
|
||||
// в таблице chats не остаётся «пустой» строки без полного состава.
|
||||
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []uuid.UUID) (*Chat, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
tx, err := s.pool.Begin(ctx)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
defer func() { _ = tx.Rollback(ctx) }()
|
||||
|
||||
chat := &Chat{
|
||||
ID: uuid.New(),
|
||||
Title: title,
|
||||
MemberIDs: append([]uuid.UUID(nil), memberIDs...),
|
||||
CreatedAt: nowUTC(),
|
||||
}
|
||||
if _, err := tx.Exec(ctx, `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)`,
|
||||
chat.ID, chat.Title, chat.CreatedAt); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
for _, uid := range memberIDs {
|
||||
// INSERT ... SELECT вставит 0 строк, если пользователя нет, и не нарушит FK.
|
||||
tag, err := tx.Exec(ctx, `
|
||||
INSERT INTO chat_members (chat_id, user_id)
|
||||
SELECT $1, id FROM users WHERE id = $2`, chat.ID, uid)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if tag.RowsAffected() != 1 {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
}
|
||||
if err := tx.Commit(ctx); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
return chat, nil
|
||||
}
|
||||
|
||||
// GetChat возвращает чат только участнику. Чужому — ErrNotFound (HTTP 404, не 403).
|
||||
func (s *Store) GetChat(ctx context.Context, chatID, userID uuid.UUID) (*Chat, error) {
|
||||
if err := s.ensureMember(ctx, chatID, userID); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return s.loadChat(ctx, chatID)
|
||||
}
|
||||
|
||||
// ListChats — keyset по (created_at, id) только среди чатов этого пользователя.
|
||||
func (s *Store) ListChats(ctx context.Context, userID uuid.UUID, limit int, after *PageCursor) ([]Chat, *PageCursor, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var (
|
||||
rows pgx.Rows
|
||||
err error
|
||||
)
|
||||
if after == nil {
|
||||
rows, err = s.pool.Query(ctx, `
|
||||
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
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $2`, userID, limit+1)
|
||||
} else {
|
||||
rows, err = s.pool.Query(ctx, `
|
||||
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
|
||||
AND (c.created_at, c.id) > ($2, $3)
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT $4`, userID, after.CreatedAt, after.ID, limit+1)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var items []Chat
|
||||
for rows.Next() {
|
||||
var c Chat
|
||||
if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
items = append(items, c)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
next, items := trimPage(items, limit, func(c Chat) (time.Time, uuid.UUID) {
|
||||
return c.CreatedAt, c.ID
|
||||
})
|
||||
for i := range items {
|
||||
members, err := s.memberIDs(ctx, items[i].ID)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
items[i].MemberIDs = members
|
||||
}
|
||||
var cursor *PageCursor
|
||||
if next {
|
||||
last := items[len(items)-1]
|
||||
cursor = &PageCursor{CreatedAt: last.CreatedAt, ID: last.ID}
|
||||
}
|
||||
return items, cursor, nil
|
||||
}
|
||||
|
||||
// CreateMessage пишет сообщение только если отправитель состоит в чате.
|
||||
// Подтверждение — это COMMIT строки. Следующее чтение видит её без кэша истории.
|
||||
func (s *Store) CreateMessage(ctx context.Context, chatID, senderID uuid.UUID, text string) (*Message, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
msg := &Message{
|
||||
ID: uuid.New(),
|
||||
ChatID: chatID,
|
||||
SenderID: senderID,
|
||||
Text: text,
|
||||
CreatedAt: nowUTC(),
|
||||
}
|
||||
tag, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT $1, $2, $3, $4, $5
|
||||
WHERE EXISTS (
|
||||
SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3
|
||||
)`, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
if tag.RowsAffected() != 1 {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return msg, nil
|
||||
}
|
||||
|
||||
// ListMessages — keyset по индексу messages_history_idx. Берём limit+1 строку,
|
||||
// чтобы next_cursor был null, когда следующей записи уже нет.
|
||||
func (s *Store) ListMessages(ctx context.Context, chatID, userID uuid.UUID, limit int, after *PageCursor) ([]Message, *PageCursor, error) {
|
||||
if err := s.ensureMember(ctx, chatID, userID); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var (
|
||||
rows pgx.Rows
|
||||
err error
|
||||
)
|
||||
if after == nil {
|
||||
rows, err = s.pool.Query(ctx, `
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2`, chatID, limit+1)
|
||||
} else {
|
||||
rows, err = s.pool.Query(ctx, `
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4`, chatID, after.CreatedAt, after.ID, limit+1)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var items []Message
|
||||
for rows.Next() {
|
||||
var m Message
|
||||
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
items = append(items, m)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, nil, mapWriteErr(err)
|
||||
}
|
||||
hasNext, items := trimPage(items, limit, func(m Message) (time.Time, uuid.UUID) {
|
||||
return m.CreatedAt, m.ID
|
||||
})
|
||||
var cursor *PageCursor
|
||||
if hasNext {
|
||||
last := items[len(items)-1]
|
||||
cursor = &PageCursor{CreatedAt: last.CreatedAt, ID: last.ID}
|
||||
}
|
||||
return items, cursor, nil
|
||||
}
|
||||
|
||||
// ChatExistsForTitle помогает тесту отката: после ошибки создания чата строки нет.
|
||||
func (s *Store) CountChatsByTitle(ctx context.Context, title string) (int, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var n int
|
||||
err := s.pool.QueryRow(ctx, `SELECT count(*) FROM chats WHERE title = $1`, title).Scan(&n)
|
||||
if err != nil {
|
||||
return 0, mapWriteErr(err)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
func (s *Store) ensureMember(ctx context.Context, chatID, userID uuid.UUID) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var one int
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2`, chatID, userID).Scan(&one)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return mapWriteErr(err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Store) loadChat(ctx context.Context, chatID uuid.UUID) (*Chat, error) {
|
||||
ctx, cancel := context.WithTimeout(ctx, queryTimeout)
|
||||
defer cancel()
|
||||
var c Chat
|
||||
err := s.pool.QueryRow(ctx, `SELECT id, title, created_at FROM chats WHERE id = $1`, chatID).
|
||||
Scan(&c.ID, &c.Title, &c.CreatedAt)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
c.MemberIDs, err = s.memberIDs(ctx, chatID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &c, nil
|
||||
}
|
||||
|
||||
func (s *Store) memberIDs(ctx context.Context, chatID uuid.UUID) ([]uuid.UUID, error) {
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT user_id FROM chat_members WHERE chat_id = $1 ORDER BY user_id`, chatID)
|
||||
if err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var ids []uuid.UUID
|
||||
for rows.Next() {
|
||||
var id uuid.UUID
|
||||
if err := rows.Scan(&id); err != nil {
|
||||
return nil, mapWriteErr(err)
|
||||
}
|
||||
ids = append(ids, id)
|
||||
}
|
||||
return ids, mapWriteErr(rows.Err())
|
||||
}
|
||||
|
||||
func trimPage[T any](items []T, limit int, _ func(T) (time.Time, uuid.UUID)) (bool, []T) {
|
||||
if len(items) > limit {
|
||||
return true, items[:limit]
|
||||
}
|
||||
return false, items
|
||||
}
|
||||
|
||||
func nowUTC() time.Time {
|
||||
// Миллисекунда — точность, которую мы же и печатаем в JSON.
|
||||
return time.Now().UTC().Truncate(time.Millisecond)
|
||||
}
|
||||
|
||||
func mapWriteErr(err error) error {
|
||||
if err == nil {
|
||||
return nil
|
||||
}
|
||||
var pgErr *pgconn.PgError
|
||||
if errors.As(err, &pgErr) && pgErr.Code == "23505" {
|
||||
return ErrConflict
|
||||
}
|
||||
if errors.Is(err, context.DeadlineExceeded) || isConn(err) {
|
||||
return ErrUnavailable
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func isConn(err error) bool {
|
||||
msg := err.Error()
|
||||
// Не логируем и не возвращаем клиенту эту строку. Здесь только классификация.
|
||||
switch {
|
||||
case errors.Is(err, pgx.ErrNoRows):
|
||||
return false
|
||||
default:
|
||||
if stringsContains(msg, "connection refused") ||
|
||||
stringsContains(msg, "failed to connect") ||
|
||||
stringsContains(msg, "conn closed") ||
|
||||
stringsContains(msg, "broken pipe") ||
|
||||
stringsContains(msg, "connection reset") ||
|
||||
stringsContains(msg, "SQLSTATE 57P01") ||
|
||||
stringsContains(msg, "SQLSTATE 08006") ||
|
||||
stringsContains(msg, "SQLSTATE 08001") {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func stringsContains(s, sub string) bool {
|
||||
return len(s) >= len(sub) && (s == sub || len(sub) == 0 ||
|
||||
(func() bool { return contains(s, sub) })())
|
||||
}
|
||||
|
||||
func contains(s, sub string) bool {
|
||||
for i := 0; i+len(sub) <= len(s); i++ {
|
||||
if s[i:i+len(sub)] == sub {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
Executable
+42
@@ -0,0 +1,42 @@
|
||||
#!/bin/sh
|
||||
# Показывает, что остановленный Redis или PostgreSQL даёт 503, а не успешный анонимный ответ.
|
||||
# Контейнеры в конце снова запущены. Токены в вывод не попадают.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
BASE=${BASE_URL:-http://127.0.0.1:8080}
|
||||
|
||||
ready() {
|
||||
curl -s -o /tmp/lab2-ready-body -w "%{http_code}" "$BASE/health/ready" || echo "curl_fail"
|
||||
}
|
||||
|
||||
echo "ready_before=$(ready)"
|
||||
echo "stop redis"
|
||||
docker compose --env-file .env stop redis
|
||||
sleep 1
|
||||
echo "ready_redis_down=$(ready)"
|
||||
echo "start redis"
|
||||
docker compose --env-file .env start redis
|
||||
for _ in 1 2 3 4 5 6 7 8 9 10; do
|
||||
code=$(ready)
|
||||
if [ "$code" = "200" ]; then
|
||||
break
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
echo "ready_redis_back=$code"
|
||||
|
||||
echo "stop postgres"
|
||||
docker compose --env-file .env stop postgres
|
||||
sleep 1
|
||||
echo "ready_postgres_down=$(ready)"
|
||||
echo "start postgres"
|
||||
docker compose --env-file .env start postgres
|
||||
for _ in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do
|
||||
code=$(ready)
|
||||
if [ "$code" = "200" ]; then
|
||||
break
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
echo "ready_postgres_back=$code"
|
||||
Executable
+19
@@ -0,0 +1,19 @@
|
||||
#!/bin/sh
|
||||
# Перезапуск API и обоих хранилищ без удаления volumes и без повторного seed.
|
||||
# Тест сохранности сам дождётся /health/ready. Скрипт только инициирует restart.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
# Сначала хранилища, затем API. API ещё и сам ждёт порт БД до 45 секунд,
|
||||
# если restart поднимет его раньше, чем Postgres примет соединения.
|
||||
docker compose --env-file .env restart postgres redis
|
||||
i=0
|
||||
while [ "$i" -lt 40 ]; do
|
||||
if docker compose --env-file .env exec -T postgres pg_isready -U "${POSTGRES_USER:-messenger}" -d "${POSTGRES_DB:-messenger}" >/dev/null 2>&1 \
|
||||
&& docker compose --env-file .env exec -T redis redis-cli ping >/dev/null 2>&1; then
|
||||
break
|
||||
fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
docker compose --env-file .env up -d --no-deps --no-build api
|
||||
Executable
+34
@@ -0,0 +1,34 @@
|
||||
#!/bin/sh
|
||||
# Трек 2: 100k сообщений, два плана запроса, pg_dump и сверка восстановления.
|
||||
# Дамп остаётся в /tmp контейнера и в git не попадает.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
if [ -f .env ]; then
|
||||
set -a
|
||||
# shellcheck disable=SC1091
|
||||
. ./.env
|
||||
set +a
|
||||
fi
|
||||
USER=${POSTGRES_USER:-messenger}
|
||||
PASS=${POSTGRES_PASSWORD:-messenger}
|
||||
export PATH="/opt/homebrew/bin:/usr/bin:/bin:$PATH"
|
||||
|
||||
docker compose --env-file .env exec -T postgres psql -U "$USER" -d postgres -v ON_ERROR_STOP=1 -c "SELECT 1" >/dev/null
|
||||
docker compose --env-file .env exec -T postgres createdb -U "$USER" track2 2>/dev/null || true
|
||||
docker compose --env-file .env exec -T postgres createdb -U "$USER" track2_restore 2>/dev/null || true
|
||||
|
||||
SRC="postgres://${USER}:${PASS}@127.0.0.1:5432/track2?sslmode=disable"
|
||||
DST="postgres://${USER}:${PASS}@127.0.0.1:5432/track2_restore?sslmode=disable"
|
||||
|
||||
go run ./cmd/track2 -mode prepare -database-url "$SRC"
|
||||
go run ./cmd/track2 -mode explain -database-url "$SRC" -out evidence/track2
|
||||
|
||||
docker compose --env-file .env exec -T postgres pg_dump -U "$USER" -d track2 -Fc -f /tmp/track2.dump
|
||||
docker compose --env-file .env exec -T postgres psql -U "$USER" -d postgres -v ON_ERROR_STOP=1 \
|
||||
-c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'track2_restore' AND pid <> pg_backend_pid();" \
|
||||
-c "DROP DATABASE IF EXISTS track2_restore" \
|
||||
-c "CREATE DATABASE track2_restore"
|
||||
docker compose --env-file .env exec -T postgres pg_restore -U "$USER" -d track2_restore --no-owner --exit-on-error /tmp/track2.dump
|
||||
go run ./cmd/track2 -mode verify -database-url "$SRC" -restore-url "$DST" -out evidence/track2
|
||||
echo "track2 ok"
|
||||
@@ -0,0 +1,433 @@
|
||||
// Собственные проверки lab2. Им нужен уже поднятый PostgreSQL и Redis
|
||||
// (docker compose up), потому что контракт требует настоящую БД, а не sqlmock.
|
||||
//
|
||||
// Каждый тест пишет в лог, что именно проверяет и какой статус получил.
|
||||
package studenttests
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"mtusi2026lab2/internal/api"
|
||||
"mtusi2026lab2/internal/auth"
|
||||
"mtusi2026lab2/internal/session"
|
||||
"mtusi2026lab2/internal/store"
|
||||
)
|
||||
|
||||
var (
|
||||
sharedStore *store.Store
|
||||
sharedSessions *session.Store
|
||||
sharedRedisURL string
|
||||
)
|
||||
|
||||
func TestMain(m *testing.M) {
|
||||
ctx := context.Background()
|
||||
dsn := getenv("DATABASE_URL", "postgres://messenger:messenger@127.0.0.1:5432/messenger?sslmode=disable")
|
||||
sharedRedisURL = getenv("REDIS_URL", "redis://127.0.0.1:6379/0")
|
||||
hasher, err := auth.NewHasher()
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "hasher:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
sharedStore, err = store.Open(ctx, dsn, hasher)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "postgres:", err)
|
||||
fmt.Fprintln(os.Stderr, "подсказка: docker compose --env-file .env up -d --build")
|
||||
os.Exit(1)
|
||||
}
|
||||
defer sharedStore.Close()
|
||||
if err := sharedStore.Migrate(ctx); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "migrate:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
// Повтор миграции не должен падать и не должен дублировать данные.
|
||||
if err := sharedStore.Migrate(ctx); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "migrate second:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
sharedSessions, err = session.Open(sharedRedisURL, time.Hour)
|
||||
if err != nil {
|
||||
fmt.Fprintln(os.Stderr, "redis:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
defer sharedSessions.Close()
|
||||
os.Exit(m.Run())
|
||||
}
|
||||
|
||||
func TestMalformedJSONAndValidation(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "битый JSON, лишнее поле, пустой текст, чужой чат")
|
||||
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/users", nil, "{")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest || !strings.Contains(body, "invalid_request") {
|
||||
t.Fatalf("malformed json: status=%d body=%s", status, body)
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/users", nil,
|
||||
`{"username":"abc","display_name":"Имя","password":"correct-horse-1","extra":1}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("extra field: status=%d", status)
|
||||
}
|
||||
|
||||
user := register(t, srv, "ok_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, token, user.id, "Чат проверки")
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{"Authorization": "Bearer " + token}, `{"text":" "}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("blank message: status=%d", status)
|
||||
}
|
||||
|
||||
outsider := register(t, srv, "outsider")
|
||||
outTok := login(t, srv, outsider.username, outsider.password)
|
||||
status, body = do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", map[string]string{"Authorization": "Bearer " + outTok}, `{"text":"чужое"}`)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusNotFound {
|
||||
t.Fatalf("foreign chat: status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "валидация JSON, пустого текста и чужого чата")
|
||||
}
|
||||
|
||||
func TestWrongPasswordLogoutAndIgnoredUserHeader(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "неверный пароль, Basic на бизнес-методе, X-User-Id, logout")
|
||||
user := register(t, srv, "auth_user")
|
||||
other := register(t, srv, "auth_other")
|
||||
|
||||
status, body, hdr := doRaw(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{
|
||||
"Authorization": "Basic " + basic(user.username, "wrong-password-1"),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnauthorized || !strings.HasPrefix(hdr.Get("WWW-Authenticate"), "Basic") {
|
||||
t.Fatalf("wrong password: status=%d www=%q", status, hdr.Get("WWW-Authenticate"))
|
||||
}
|
||||
|
||||
token := login(t, srv, user.username, user.password)
|
||||
status, body, hdr = doRaw(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{
|
||||
"Authorization": "Basic " + basic(user.username, user.password),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnauthorized || !strings.HasPrefix(hdr.Get("WWW-Authenticate"), "Bearer") {
|
||||
t.Fatalf("basic on business endpoint: status=%d www=%q", status, hdr.Get("WWW-Authenticate"))
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"X-User-Id": user.id}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("X-User-Id alone: status=%d", status)
|
||||
}
|
||||
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{
|
||||
"Authorization": "Bearer " + token,
|
||||
"X-User-Id": other.id,
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusOK || !strings.Contains(body, user.id) || strings.Contains(body, other.id) {
|
||||
t.Fatalf("X-User-Id overrode bearer: status=%d body=%s", status, body)
|
||||
}
|
||||
|
||||
status, _ = do(t, srv, http.MethodDelete, "/api/v1/auth/sessions/current", map[string]string{"Authorization": "Bearer " + token}, "")
|
||||
t.Logf("logout status=%d", status)
|
||||
if status != http.StatusNoContent {
|
||||
t.Fatalf("logout status=%d", status)
|
||||
}
|
||||
status, _ = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"Authorization": "Bearer " + token}, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("token still valid after logout: %d", status)
|
||||
}
|
||||
status, _ = do(t, srv, http.MethodDelete, "/api/v1/auth/sessions/current", map[string]string{"Authorization": "Bearer " + token}, "")
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("second logout status=%d", status)
|
||||
}
|
||||
logOK(t, "пароль, заголовки и отзыв сессии")
|
||||
}
|
||||
|
||||
func TestSessionExpiry(t *testing.T) {
|
||||
srv := newAPI(t, 2*time.Second)
|
||||
defer srv.Close()
|
||||
logStep(t, "SESSION_TTL=2s: тот же токен после паузы должен стать 401, TTL рестартом API не продлевается")
|
||||
user := register(t, srv, "ttl_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
time.Sleep(2500 * time.Millisecond)
|
||||
status, body := do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{"Authorization": "Bearer " + token}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusUnauthorized {
|
||||
t.Fatalf("expired token status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "истёкшая сессия отклонена")
|
||||
}
|
||||
|
||||
func TestDuplicateUsernameRace(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
name := "race_" + uuid.NewString()[:8]
|
||||
logStep(t, "8 параллельных регистраций username="+name)
|
||||
const n = 8
|
||||
codes := make([]int, n)
|
||||
var wg sync.WaitGroup
|
||||
body := fmt.Sprintf(`{"username":%q,"display_name":"Гонка","password":"correct-horse-1"}`, name)
|
||||
for i := 0; i < n; i++ {
|
||||
wg.Add(1)
|
||||
go func(i int) {
|
||||
defer wg.Done()
|
||||
status, _ := do(t, srv, http.MethodPost, "/api/v1/users", nil, body)
|
||||
codes[i] = status
|
||||
}(i)
|
||||
}
|
||||
wg.Wait()
|
||||
ok, conflict := 0, 0
|
||||
for _, c := range codes {
|
||||
switch c {
|
||||
case http.StatusCreated:
|
||||
ok++
|
||||
case http.StatusConflict:
|
||||
conflict++
|
||||
default:
|
||||
t.Errorf("unexpected status %d", c)
|
||||
}
|
||||
}
|
||||
t.Logf("created=%d conflict=%d", ok, conflict)
|
||||
if ok != 1 || conflict != n-1 {
|
||||
t.Fatalf("race result created=%d conflict=%d", ok, conflict)
|
||||
}
|
||||
logOK(t, "UNIQUE username выдержал гонку")
|
||||
}
|
||||
|
||||
func TestChatCreateRollsBack(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
user := register(t, srv, "roll_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
title := "rollback-" + uuid.NewString()
|
||||
missing := uuid.NewString()
|
||||
logStep(t, "создание чата с несуществующим участником должно откатиться, title="+title)
|
||||
raw := fmt.Sprintf(`{"title":%q,"member_ids":[%q,%q]}`, title, user.id, missing)
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats", map[string]string{"Authorization": "Bearer " + token}, raw)
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusBadRequest {
|
||||
t.Fatalf("status=%d", status)
|
||||
}
|
||||
n, err := sharedStore.CountChatsByTitle(context.Background(), title)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Logf("строк chats с этим title после ошибки: %d", n)
|
||||
if n != 0 {
|
||||
t.Fatalf("chat row survived rollback: %d", n)
|
||||
}
|
||||
logOK(t, "транзакция создания чата откатилась")
|
||||
}
|
||||
|
||||
func TestPaginationPages(t *testing.T) {
|
||||
srv := newAPI(t, time.Hour)
|
||||
defer srv.Close()
|
||||
logStep(t, "три сообщения, две страницы limit=2, затем последняя")
|
||||
user := register(t, srv, "page_user")
|
||||
token := login(t, srv, user.username, user.password)
|
||||
chat := createChat(t, srv, token, user.id, "Страницы")
|
||||
auth := map[string]string{"Authorization": "Bearer " + token}
|
||||
for _, text := range []string{"раз", "два", "три"} {
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", auth, fmt.Sprintf(`{"text":%q}`, text))
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("post message %s: %d %s", text, status, body)
|
||||
}
|
||||
}
|
||||
status, body := do(t, srv, http.MethodGet, "/api/v1/chats/"+chat+"/messages?limit=2", auth, "")
|
||||
logResult(t, status, body)
|
||||
page := decode(t, body)
|
||||
items, _ := page["items"].([]any)
|
||||
if status != http.StatusOK || len(items) != 2 || page["next_cursor"] == nil {
|
||||
t.Fatalf("page1: %+v", page)
|
||||
}
|
||||
cursor, _ := page["next_cursor"].(string)
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/chats/"+chat+"/messages?limit=2&cursor="+cursor, auth, "")
|
||||
logResult(t, status, body)
|
||||
page = decode(t, body)
|
||||
items, _ = page["items"].([]any)
|
||||
if len(items) != 1 || page["next_cursor"] != nil {
|
||||
t.Fatalf("page2: %+v", page)
|
||||
}
|
||||
logOK(t, "keyset обошёл историю без зависания cursor")
|
||||
}
|
||||
|
||||
func TestRedisDownIsNotAnonymous(t *testing.T) {
|
||||
logStep(t, "закрытый клиент Redis: вход и Bearer дают 503, а не 200 от анонима")
|
||||
closed, err := session.Open(sharedRedisURL, time.Hour)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := closed.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
srv := httptest.NewServer(api.New(sharedStore, closed).Handler())
|
||||
defer srv.Close()
|
||||
regSrv := newAPI(t, time.Hour)
|
||||
defer regSrv.Close()
|
||||
user := register(t, regSrv, "redis_down")
|
||||
// register() opened another server; login against the closed-redis server.
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{
|
||||
"Authorization": "Basic " + basic(user.username, user.password),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable {
|
||||
t.Fatalf("login with dead redis: status=%d body=%s", status, body)
|
||||
}
|
||||
status, body = do(t, srv, http.MethodGet, "/api/v1/users/me", map[string]string{
|
||||
"Authorization": "Bearer " + strings.Repeat("ab", 32),
|
||||
}, "")
|
||||
logResult(t, status, body)
|
||||
if status != http.StatusServiceUnavailable {
|
||||
t.Fatalf("bearer with dead redis: status=%d body=%s", status, body)
|
||||
}
|
||||
logOK(t, "сбой Redis не стал анонимным доступом")
|
||||
}
|
||||
|
||||
type account struct {
|
||||
id string
|
||||
username string
|
||||
password string
|
||||
}
|
||||
|
||||
func newAPI(t *testing.T, ttl time.Duration) *httptest.Server {
|
||||
t.Helper()
|
||||
sessions, err := session.Open(sharedRedisURL, ttl)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() { _ = sessions.Close() })
|
||||
return httptest.NewServer(api.New(sharedStore, sessions).Handler())
|
||||
}
|
||||
|
||||
func register(t *testing.T, srv *httptest.Server, prefix string) account {
|
||||
t.Helper()
|
||||
username := prefix + "_" + uuid.NewString()[:8]
|
||||
password := "correct-horse-1"
|
||||
raw := fmt.Sprintf(`{"username":%q,"display_name":"Студент","password":%q}`, username, password)
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/users", nil, raw)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("register %s: %d %s", username, status, body)
|
||||
}
|
||||
var u struct {
|
||||
ID string `json:"id"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(body), &u); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Logf("создан %s id=%s", username, u.ID)
|
||||
return account{id: u.ID, username: username, password: password}
|
||||
}
|
||||
|
||||
func login(t *testing.T, srv *httptest.Server, username, password string) string {
|
||||
t.Helper()
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/auth/sessions", map[string]string{
|
||||
"Authorization": "Basic " + basic(username, password),
|
||||
}, "")
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("login %s: %d %s", username, status, body)
|
||||
}
|
||||
var s struct {
|
||||
Token string `json:"token"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(body), &s); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(s.Token) < 32 {
|
||||
t.Fatalf("token too short: %d", len(s.Token))
|
||||
}
|
||||
t.Logf("сессия выпущена, длина токена=%d (значение не печатаем)", len(s.Token))
|
||||
return s.Token
|
||||
}
|
||||
|
||||
func createChat(t *testing.T, srv *httptest.Server, token, userID, title string) string {
|
||||
t.Helper()
|
||||
raw := fmt.Sprintf(`{"title":%q,"member_ids":[%q]}`, title, userID)
|
||||
status, body := do(t, srv, http.MethodPost, "/api/v1/chats", map[string]string{"Authorization": "Bearer " + token}, raw)
|
||||
if status != http.StatusCreated {
|
||||
t.Fatalf("chat: %d %s", status, body)
|
||||
}
|
||||
var c struct {
|
||||
ID string `json:"id"`
|
||||
}
|
||||
if err := json.Unmarshal([]byte(body), &c); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return c.ID
|
||||
}
|
||||
|
||||
func do(t *testing.T, srv *httptest.Server, method, path string, headers map[string]string, raw string) (int, string) {
|
||||
t.Helper()
|
||||
status, body, _ := doRaw(t, srv, method, path, headers, raw)
|
||||
return status, body
|
||||
}
|
||||
|
||||
func doRaw(t *testing.T, srv *httptest.Server, method, path string, headers map[string]string, raw string) (int, string, http.Header) {
|
||||
t.Helper()
|
||||
var rdr io.Reader
|
||||
if raw != "" {
|
||||
rdr = bytes.NewBufferString(raw)
|
||||
}
|
||||
req, err := http.NewRequest(method, srv.URL+path, rdr)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if raw != "" && method != http.MethodGet {
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
}
|
||||
for k, v := range headers {
|
||||
req.Header.Set(k, v)
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
b, _ := io.ReadAll(resp.Body)
|
||||
return resp.StatusCode, string(b), resp.Header
|
||||
}
|
||||
|
||||
func decode(t *testing.T, body string) map[string]any {
|
||||
t.Helper()
|
||||
var m map[string]any
|
||||
if err := json.Unmarshal([]byte(body), &m); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func basic(user, pass string) string {
|
||||
return base64.StdEncoding.EncodeToString([]byte(user + ":" + pass))
|
||||
}
|
||||
|
||||
func logStep(t *testing.T, msg string) { t.Helper(); t.Logf("→ %s", msg) }
|
||||
func logOK(t *testing.T, msg string) { t.Helper(); t.Logf("✓ %s", msg) }
|
||||
func logResult(t *testing.T, status int, body string) {
|
||||
t.Helper()
|
||||
if len(body) > 400 {
|
||||
body = body[:400] + "..."
|
||||
}
|
||||
t.Logf("status=%d body=%s", status, body)
|
||||
}
|
||||
|
||||
func getenv(k, def string) string {
|
||||
if v := os.Getenv(k); v != "" {
|
||||
return v
|
||||
}
|
||||
return def
|
||||
}
|
||||
Reference in New Issue
Block a user