Перенести мессенджер на PostgreSQL и сессии Redis.
Skeleton contracts / contracts (pull_request) Canceled after 0s

Сообщения должны переживать рестарт, а доступ идти через Bearer, а не X-User-Id. Трек 2 сравнивает план keyset-запроса и сверяет pg_restore.
This commit is contained in:
Mlvn
2026-10-14 22:47:08 +03:00
parent 65003b6119
commit 096c53ecdb
29 changed files with 3384 additions and 23 deletions
+11 -7
View File
@@ -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
View File
@@ -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"]
+9 -1
View File
@@ -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
+71 -15
View File
@@ -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, не распределённый бенчмарк.
+158
View File
@@ -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
}
+509
View File
@@ -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)
}
+60
View File
@@ -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:
+9
View File
@@ -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
+3
View File
@@ -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.
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+106
View File
@@ -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
+77
View File
@@ -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": []
}
]
}
+139
View File
@@ -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": []
}
]
}
+13
View File
@@ -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"
}
+5
View File
@@ -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
+13
View File
@@ -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
}
}
+21
View File
@@ -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
)
+42
View File
@@ -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=
+630
View File
@@ -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
}
+110
View File
@@ -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)
}
+84
View File
@@ -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
}
+135
View File
@@ -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[:])
}
+84
View File
@@ -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
}
+49
View File
@@ -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);
+496
View File
@@ -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
}
+42
View File
@@ -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"
+19
View File
@@ -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
+34
View File
@@ -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"
+433
View File
@@ -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
}