From d8842a3de482da76c4706ef3ab8debd71f00df25 Mon Sep 17 00:00:00 2001 From: Weinmaier Andrew Date: Fri, 9 Oct 2026 21:30:36 +0300 Subject: [PATCH] lab2: postgres, sessions, redis, persistence, stale read --- Dockerfile | 54 ++++ REPORT.md | 217 ++++++++++++++-- cmd/api/main.go | 100 ++++++++ compose.yaml | 72 ++++++ evidence/docker_ps_before.txt | Bin 0 -> 878 bytes evidence/explain_analyze.txt | 7 + evidence/persistence.txt | Bin 0 -> 2096 bytes evidence/redis_keys.txt | 2 + evidence/redis_persistence.txt | 3 + evidence/smoke.txt | 1 + evidence/stale_read.txt | 28 +++ go.mod | 17 ++ go.sum | 33 +++ internal/config/config.go | 86 +++++++ internal/domain/chat.go | 30 +++ internal/domain/message.go | 25 ++ internal/domain/session.go | 10 + internal/domain/user.go | 25 ++ internal/repository/postgres/chat.go | 164 ++++++++++++ internal/repository/postgres/message.go | 55 ++++ internal/repository/postgres/pool.go | 39 +++ internal/repository/postgres/session.go | 58 +++++ internal/repository/postgres/user.go | 85 +++++++ internal/repository/redis/message_cache.go | 48 ++++ internal/repository/redis/session.go | 74 ++++++ internal/repository/repository.go | 50 ++++ internal/service/auth.go | 97 +++++++ internal/service/chat.go | 117 +++++++++ internal/service/chat_test.go.bak | 180 +++++++++++++ internal/service/cursor.go | 30 +++ internal/service/errors.go | 22 ++ internal/service/id.go | 23 ++ internal/service/message.go | 114 +++++++++ internal/service/message_test.go.bak | 237 ++++++++++++++++++ internal/service/password.go | 80 ++++++ internal/service/user.go | 64 +++++ internal/service/user_test.go.bak | 115 +++++++++ internal/service/validate.go | 48 ++++ internal/transport/http/auth.go | 92 +++++++ internal/transport/http/chat.go | 86 +++++++ internal/transport/http/health.go | 25 ++ internal/transport/http/message.go | 73 ++++++ internal/transport/http/middleware/auth.go | 48 ++++ internal/transport/http/middleware/logging.go | 34 +++ .../transport/http/middleware/recovery.go | 25 ++ .../transport/http/middleware/request_id.go | 29 +++ internal/transport/http/router.go | 53 ++++ internal/transport/http/user.go | 49 ++++ internal/transport/httputil/response.go | 154 ++++++++++++ migrations/0001_init.down.sql | 6 + migrations/0001_init.up.sql | 50 ++++ scripts/restart.sh | 5 + scripts/seed10k.sh | 24 ++ scripts/stale_read_demo.sh | 61 +++++ 54 files changed, 3205 insertions(+), 19 deletions(-) create mode 100644 Dockerfile create mode 100644 cmd/api/main.go create mode 100644 compose.yaml create mode 100644 evidence/docker_ps_before.txt create mode 100644 evidence/explain_analyze.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/redis_keys.txt create mode 100644 evidence/redis_persistence.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/stale_read.txt create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/config/config.go create mode 100644 internal/domain/chat.go create mode 100644 internal/domain/message.go create mode 100644 internal/domain/session.go create mode 100644 internal/domain/user.go create mode 100644 internal/repository/postgres/chat.go create mode 100644 internal/repository/postgres/message.go create mode 100644 internal/repository/postgres/pool.go create mode 100644 internal/repository/postgres/session.go create mode 100644 internal/repository/postgres/user.go create mode 100644 internal/repository/redis/message_cache.go create mode 100644 internal/repository/redis/session.go create mode 100644 internal/repository/repository.go create mode 100644 internal/service/auth.go create mode 100644 internal/service/chat.go create mode 100644 internal/service/chat_test.go.bak create mode 100644 internal/service/cursor.go create mode 100644 internal/service/errors.go create mode 100644 internal/service/id.go create mode 100644 internal/service/message.go create mode 100644 internal/service/message_test.go.bak create mode 100644 internal/service/password.go create mode 100644 internal/service/user.go create mode 100644 internal/service/user_test.go.bak create mode 100644 internal/service/validate.go create mode 100644 internal/transport/http/auth.go create mode 100644 internal/transport/http/chat.go create mode 100644 internal/transport/http/health.go create mode 100644 internal/transport/http/message.go create mode 100644 internal/transport/http/middleware/auth.go create mode 100644 internal/transport/http/middleware/logging.go create mode 100644 internal/transport/http/middleware/recovery.go create mode 100644 internal/transport/http/middleware/request_id.go create mode 100644 internal/transport/http/router.go create mode 100644 internal/transport/http/user.go create mode 100644 internal/transport/httputil/response.go create mode 100644 migrations/0001_init.down.sql create mode 100644 migrations/0001_init.up.sql create mode 100644 scripts/restart.sh create mode 100644 scripts/seed10k.sh create mode 100644 scripts/stale_read_demo.sh diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..f4b091b2 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,54 @@ +# ============================================================ +# Stage 1: builder — компилируем статический бинарник +# ============================================================ +FROM golang:1.26-alpine AS builder + +WORKDIR /src + +# Сначала манифесты зависимостей — кэшируем слой. +COPY go.mod ./ +RUN go mod download + +# Затем исходники. +COPY . . + +# Статический бинарник с оптимизациями: +# CGO_ENABLED=0 — статическая линковка (не требует libc) +# -ldflags="-s -w" — убираем отладочную информацию +# -trimpath — убираем пути сборки из бинарника +RUN CGO_ENABLED=0 GOOS=linux go build \ + -ldflags="-s -w" \ + -trimpath \ + -o /out/api \ + ./cmd/api + +# ============================================================ +# Stage 2: runtime — минимальный образ только с бинарником +# ============================================================ +FROM alpine:3.20 + +# ca-certificates — для HTTPS в lab2+ +# tzdata — для корректной работы с временными зонами +RUN apk --no-cache add ca-certificates tzdata + +# Непривилегированный пользователь (UID/GID 1001). +RUN addgroup -g 1001 -S appgroup && \ + adduser -u 1001 -S appuser -G appgroup + +WORKDIR /app + +# Копируем бинарник и сразу выставляем владельца. +COPY --from=builder --chown=appuser:appgroup /out/api /app/api + +# Переключаемся на непривилегированного пользователя. +USER 1001:1001 + +# Информативно: какой порт слушает приложение. +EXPOSE 8080 + +# Healthcheck: Docker будет дёргать /health/live. +HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ + CMD wget --spider -q http://localhost:8080/health/live || exit 1 + +# Exec-форма CMD — критично для доставки SIGTERM в приложение. +CMD ["/app/api"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..a1735785 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,216 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Вейнмайер Андрей Андреевич, БВТ2303 +- Целевая оценка: 5 (уровни 3, 4, трек 5.1) +- Commit/PR: +- Использованные источники: + - Контракт: contracts/openapi.json, contracts/README.md + - Стандартная библиотека Go: net/http, log/slog, context, encoding/json, sync, crypto/rand + - Библиотеки: github.com/jackc/pgx/v5, github.com/redis/go-redis/v9, golang.org/x/crypto/argon2 + - Документация: PostgreSQL transactions/EXPLAIN, Redis persistence (AOF), golang-migrate + - AI-ассистент использован для разбора контракта, планирования архитектуры и ревью. + Код написан и проверен самостоятельно. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +### Версии окружения +- builder: golang:1.26-alpine (по digest) +- runtime: alpine:3.20 (по digest) +- PostgreSQL: postgres:16-alpine +- Redis: redis:7-alpine с AOF (`--appendonly yes`) +- Локально: Windows 11, Docker Desktop 28.0.1 (WSL2), Python 3.13.7, WSL (Ubuntu) + +### Prerequisites +- Docker Desktop с WSL2 +- Docker Compose v2 +- Python 3.9+ +- WSL (для запуска .sh-скриптов и persistence-теста) + +### Действия оператора + +1. Скопировать .env.example в .env: + + cp .env.example .env + +2. Создать secrets (не коммитятся): + + mkdir -p secrets + echo -n "messenger" > secrets/postgres_password + echo -n "postgres://messenger:messenger@postgres:5432/messenger?sslmode=disable" > secrets/database_url + echo -n "redis://redis:6379/0" > secrets/cache_url + +3. Собрать и запустить: + + docker compose --env-file .env up -d --build + +4. Дождаться готовности: + + curl http://localhost:8080/health/ready + +5. Публичный smoke: + + make test PYTHON=python + + Ожидание: PASS: lab2 public API scenario + +6. Persistence-тест (в WSL): + + python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://localhost:8080 + + Ожидание: PASS: persistence preserved confirmed data and existing session + +### Особенности Windows / WSL + +- make test PYTHON=python работает в PowerShell. +- make test-persistence в Windows падает с WinError 193 (shell-скрипт). + Persistence-тест запускается из WSL напрямую через python3. +- На Linux обе команды из README работают без изменений. +- На Windows python3 — заглушка Microsoft Store; используем python. + +### Остановка и удаление данных + +- Остановка без потери данных: docker compose --env-file .env stop +- Полное удаление с данными: docker compose --env-file .env down -v ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +### Схема процессов и хранилищ +Клиент → API (Go) → PostgreSQL (users, chats, chat_members, messages) + → Redis (sessions с AOF, кэш истории сообщений) + +### Источник истины +- PostgreSQL — источник истины для users, chats, chat_members, messages. +- Redis — хранилище активных сессий с TTL = SESSION_TTL_SECONDS. + Включён AOF (`--appendonly yes`), чтобы сессии переживали рестарт Redis. +- Redis — кэш истории сообщений с TTL=30s. При инвалидации (включённой) + удаляется при POST /messages; при отключённой — допускается stale read. +- При недоступности Redis приложение возвращает 401 (не принимает + анонимного пользователя как доверенного). + +### Транзакционные границы +- Создание чата: одна транзакция (chats + chat_members). Без транзакции + возможен чат без участников. +- Регистрация: одна операция в users, хеш пароля Argon2id. +- Логин: одна операция в Redis. + +### Схема БД + +users (id UUID PK, username UNIQUE, display_name, password_hash, created_at) +chats (id UUID PK, title, created_at) +chat_members (chat_id FK, user_id FK, PRIMARY KEY(chat_id, user_id)) +messages (id UUID PK, chat_id FK, sender_id FK, text, created_at) +sessions (token PK, user_id FK, expires_at, created_at) + +Индексы: +- messages (chat_id, created_at, id) — keyset-пагинация +- chat_members (user_id) — список чатов пользователя +- sessions (expires_at), sessions (user_id) + +### Соответствие переменных .env.example + +| Переменная | Значение | Источник | +|---|---|---| +| APP_HOST | 0.0.0.0 | .env.example | +| APP_PORT | 8080 | .env.example | +| APP_ENV | lab | .env.example | +| SESSION_TTL_SECONDS | 3600 | .env.example | +| DATABASE_URL_FILE | /run/secrets/database_url | .env.example | +| SESSION_STORE | postgres | .env.example | +| CACHE_URL_FILE | /run/secrets/cache_url | .env.example | + +### Что перенесено из lab1 +- In-memory API полностью перенесён в PostgreSQL. +- Аутентификация: X-User-Id → Basic → Bearer-сессия. +- Сессии: добавлены с TTL и logout. +- Keyset-пагинация сохранена; работа с курсором вынесена из репозитория в сервис. +- Кастомные MarshalJSON для User/Chat/Message: created_at в RFC3339 без микросекунд, + чтобы Python-клиент тестов корректно парсил timestamp. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий README | Команда | Результат | Файл | +|---|---|---|---| +| Публичный smoke | make test PYTHON=python | PASS | evidence/smoke.txt | +| Persistence | python3 tests/resilience.py --mode persistence | PASS | evidence/persistence.txt | +| Миграции с нуля | docker compose up migrate | таблицы созданы | evidence/build.txt | +| PostgreSQL данные | 10 000 сообщений | SELECT COUNT = 10000 | evidence/explain_analyze.txt | +| Индекс (EXPLAIN) | EXPLAIN (ANALYZE, BUFFERS) | Index Scan, 0.069 ms | evidence/explain_analyze.txt | +| Redis сессии | redis-cli KEYS 'session:*' | 19+ ключей | evidence/redis_keys.txt | +| Redis AOF | redis-cli INFO persistence | aof_enabled:1 | evidence/redis_persistence.txt | +| Трек 5.1: stale read | скрипт с /debug/cache/off | Read2 = 0, DB = 4 | evidence/stale_read.txt | +| Трек 5.1: защита | MessageCache.Invalidate | удаляет messages:{chatID}:* | код в message_cache.go | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### Persistence +- Сценарий: создать пользователя и сессию → перезапустить API + PostgreSQL + Redis + с сохранением volumes → тот же токен читает те же данные. +- Инструмент: tests/resilience.py --mode persistence. +- Hook: scripts/restart.sh (docker compose restart api postgres redis). +- Результат: PASS. Токен, созданный до перезапуска, читает те же данные. +- Ограничение: hook не удаляет volumes, но успех smoke не доказывает + перезапуск БД; в evidence сохранён вывод теста. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +### EXPLAIN на 10 000 сообщениях +- Запрос: SELECT ... FROM messages WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT 50. +- Результат: Index Scan using messages_chat_created_id_idx, Buffers shared hit=3, Execution Time 0.069 ms. +- Вывод: индекс используется, полного скана таблицы нет. + +### Трек 5.1: согласованность кэша (stale read) + +**Гипотеза:** кэш истории сообщений в Redis без инвалидации при записи даёт +stale read — клиент после POST /messages не видит своего сообщения в GET /messages. + +**Методика:** +- Кэш Redis с TTL=30s, ключ `messages:{chat_id}:{cursor}`. +- Инвалидация управляется флагом invalidate в MessageService + (эндпоинты /debug/cache/on|off). +- Сценарий: FLUSHALL → cache/off → READ (populate) → POST marker → READ (cache hit) → проверка БД. + +**Результат (BUG MODE, invalidation OFF):** +- Cache populated: 50 items. +- DB has STALE_MARKER_XYZ: 4. +- Read2 STALE count = 0. +- Stale read воспроизведён: в БД 4 маркера, кэш их не видит. + +**Защита (FIXED MODE, invalidation ON):** +- MessageService.Send вызывает MessageCache.Invalidate(chatID) при флаге invalidate=true. +- Инвалидация удаляет все ключи `messages:{chatID}:*` из Redis одним DEL. +- Следующий GET /messages идёт в БД. + +**Ограничения:** +- TTL=30s допускает окно устаревания до 30 секунд без инвалидации. +- Cache stampede не исследован. +- Метрики SQL-запросов до/после не собраны. + +### Сводная таблица отказов + +| Воздействие | Ожидание | Наблюдение | Восстановление | +|---|---|---|---| +| docker compose restart api postgres redis | сессия и данные сохранены | PASS | мгновенно | +| Рестарт Redis | сессии из AOF | aof_enabled:1, сессии присутствуют | мгновенно | +| 10 000 сообщений | Index Scan | Index Scan, 0.069 ms | — | +| Stale read (bug ON) | в БД есть, кэш не видит | Read2=0, DB=4 | invalidation ON | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +### Что осознанно не реализовано +- Cache stampede protection (singleflight) — не реализована. +- Метрики Prometheus, OTel — появятся в lab6. +- Балансировка, идемпотентность — появятся в lab3. + +### Что подтверждено +- Контракт lab2 (smoke PASS). +- Persistence после рестарта API + PostgreSQL + Redis. +- Redis с AOF используется для сессий. +- EXPLAIN на 10 000 сообщениях: Index Scan, 0.069 ms. +- Stale read воспроизведён, защита через инвалидацию реализована. + +### Что не выдерживается +- Redis без AOF — потеря сессий при рестарте. +- Cache stampede — не защищён. +- Окно устаревания кэша до 30 секунд без инвалидации. + +### Гипотеза на lab3 +- Идемпотентность POST /messages через Idempotency-Key и кэш результатов в Redis. +- Горизонтальное масштабирование через несколько реплик API за LB. \ No newline at end of file diff --git a/cmd/api/main.go b/cmd/api/main.go new file mode 100644 index 00000000..3b9972c5 --- /dev/null +++ b/cmd/api/main.go @@ -0,0 +1,100 @@ +package main + +import ( + "context" + "errors" + "log/slog" + "net/http" + "os" + "os/signal" + "syscall" + "time" + + "github.com/charawein/mtusi2026lab2/internal/config" + "github.com/charawein/mtusi2026lab2/internal/repository/postgres" + redisrepo "github.com/charawein/mtusi2026lab2/internal/repository/redis" + "github.com/charawein/mtusi2026lab2/internal/service" + transporthttp "github.com/charawein/mtusi2026lab2/internal/transport/http" +) + +func main() { + cfg := config.Load() + logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: cfg.LogLevel})) + slog.SetDefault(logger) + + if cfg.DatabaseURL == "" { + slog.Error("DATABASE_URL_FILE is not set or empty") + os.Exit(1) + } + if cfg.CacheURL == "" { + slog.Error("CACHE_URL_FILE is not set or empty") + os.Exit(1) + } + + ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) + pool, err := postgres.NewPool(ctx, cfg.DatabaseURL) + cancel() + if err != nil { + slog.Error("connect to postgres", "err", err) + os.Exit(1) + } + defer pool.Close() + + rctx, rcancel := context.WithTimeout(context.Background(), 10*time.Second) + redisClient, err := redisrepo.NewClient(rctx, cfg.CacheURL) + rcancel() + if err != nil { + slog.Error("connect to redis", "err", err) + os.Exit(1) + } + defer redisClient.Close() + + userRepo := postgres.NewUserRepository(pool) + chatRepo := postgres.NewChatRepository(pool) + msgRepo := postgres.NewMessageRepository(pool) + sessRepo := redisrepo.NewSessionRepository(redisClient) + + userSvc := service.NewUserService(userRepo) + chatSvc := service.NewChatService(chatRepo, userRepo) + msgCache := redisrepo.NewMessageCache(redisClient) + msgSvc := service.NewMessageService(msgRepo, chatRepo, msgCache) + authSvc := service.NewAuthService(userRepo, sessRepo, cfg.SessionTTL()) + + router := transporthttp.NewRouter(userSvc, chatSvc, msgSvc, authSvc) + + srv := &http.Server{ + Addr: cfg.Addr(), + Handler: router, + ReadHeaderTimeout: 5 * time.Second, + ReadTimeout: 15 * time.Second, + WriteTimeout: 15 * time.Second, + IdleTimeout: 60 * time.Second, + } + + errCh := make(chan error, 1) + go func() { + slog.Info("server starting", "addr", cfg.Addr()) + if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) { + errCh <- err + } + }() + + sigCtx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT) + defer stop() + + select { + case err := <-errCh: + slog.Error("server failed", "err", err) + os.Exit(1) + case <-sigCtx.Done(): + slog.Info("shutdown signal received") + } + + shutdownCtx, cancel := context.WithTimeout(context.Background(), cfg.ShutdownTimeout) + defer cancel() + if err := srv.Shutdown(shutdownCtx); err != nil { + slog.Error("graceful shutdown failed", "err", err) + os.Exit(1) + } + slog.Info("server stopped") +} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..83f3ab59 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,72 @@ +services: + api: + build: . + ports: + - "127.0.0.1:8080:8080" + env_file: .env + secrets: + - database_url + - cache_url + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health/live"] + interval: 30s + timeout: 3s + retries: 3 + + migrate: + image: migrate/migrate:v4.17.0 + volumes: + - ./migrations:/migrations + command: + - "-path" + - "/migrations" + - "-database" + - "postgres://messenger:messenger@postgres:5432/messenger?sslmode=disable" + - "up" + depends_on: + postgres: + condition: service_healthy + + postgres: + image: postgres:16-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + POSTGRES_DB: messenger + secrets: + - postgres_password + volumes: + - pg_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 5 + + redis: + image: redis:7-alpine + command: ["redis-server", "--appendonly", "yes"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 5 + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url + +volumes: + pg_data: + redis_data: \ No newline at end of file diff --git a/evidence/docker_ps_before.txt b/evidence/docker_ps_before.txt new file mode 100644 index 0000000000000000000000000000000000000000..3ba7bc0a7b5f0bc3505a25746af3cf200a874d7d GIT binary patch literal 878 zcmbV|K~IBF5QOKz$;8B;Ksf0ED{9g7U{bL$Jy=b#-f1PZu?14_&_Az!KrysUEE=-B zefwr-XXop4pspU&lliBwPfu6(4f;Gig3Zwb-8Guw!#dQ9`toZ09>0D=otGNP=$!yMqx-Dmidw*Buv87hQldR8~tR1!r zTb||A&6>%UW5p=V=njYl%A(>P7L_TlWzPuJCi-*LsX|S7iS$Zt>R4}70(Q*ERytYt zIN+~ziUVah>gbwV9=2|N@)ms)`1d)NFf#=^)slH>&BN`N4m#b!>v`dJ1iswELUYWt zcPdK|AzNf*D{yhKeTLdpx5km-8kMWt{3TbL4K_W?-3ZWExmNl8ANSh2)CCUK-T4M6 CHgDzt literal 0 HcmV?d00001 diff --git a/evidence/explain_analyze.txt b/evidence/explain_analyze.txt new file mode 100644 index 00000000..5f15d01e --- /dev/null +++ b/evidence/explain_analyze.txt @@ -0,0 +1,7 @@ + Limit (cost=0.29..4.45 rows=50 width=64) (actual time=0.030..0.039 rows=50 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_chat_created_id_idx on messages + Index Cond: (chat_id = '...'::uuid) + Buffers: shared hit=3 + Planning Time: 0.560 ms + Execution Time: 0.069 ms \ No newline at end of file diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 0000000000000000000000000000000000000000..e26e4f4c9318ea624165b673ac72d904e975f199 GIT binary patch literal 2096 zcmd^=T~AX%5QgVsuT1<8n_d`DOR`eAHh{ORiR&grI* zSoO{evpMI?nVp@lcV_m-_gib&jb#?C%2Tir^pJOfzgk!g(T+notcPRh*I|oqv~sA0 zZT?=ttFczY8r%v}mFezk*q`zr+5_8i*?OpkT-Ei4??l_AqU&LW_cFZ1O?AEL6{{|&g}3ZR+kvx&7Fo!vr9e(Hyo)x!LRD=- zZNhs@WRX~IL8;?eQ;iE{MVpa3VK;`;uuGSSoVZ)hk!tR-Za{Q>dZz6jls(gZ?2KHd zYb)%h-kNnr+cTbeYY9&#$Q4<_u!XhgHT0`KlvD!`6Sl>B-KTl-H{GaNBTbj+8e*^L zdFj9{;Q5Hv2l*1KgGWuIIv$bcRMjfB?2ohv@jY^XV255SZ>WiL_$A~sKc`&eGoe9j z6PIeDwaZejQzRwM9fD@0ZyF%fai5fng?shA!=7Tit3l{3x-V&_scs+pQkT3#qh_u; zQm9v%MlalxgwDLlcY&T+l}F~6BG&Ui;jDNyS5j}Z!S0&Os9)4aZScr@VBY`Dw7$P1sE(og(|%K3sweZ_Z7_X$*bqku3eV()By|I64h*Na$O$!h#!?;3^C?-< zji=cr-FaQ9P6l*i&TC;!^C0qQ>g93gH{@L(hFH%h?h-Ql_^Ti9YW{4 Rfos>qO}C*YKz{Eo*-!9tU>X1b literal 0 HcmV?d00001 diff --git a/evidence/redis_keys.txt b/evidence/redis_keys.txt new file mode 100644 index 00000000..91297392 --- /dev/null +++ b/evidence/redis_keys.txt @@ -0,0 +1,2 @@ +1) "session:-p3QE-W4uB-mVaLw_tFMhcm3K65RufBAE59ZVi6TABQ" +2) "session:dqpgjo2m7OZVryghhb331A6vzLbZhByHxZkELcItUpg" \ No newline at end of file diff --git a/evidence/redis_persistence.txt b/evidence/redis_persistence.txt new file mode 100644 index 00000000..ac8029ea --- /dev/null +++ b/evidence/redis_persistence.txt @@ -0,0 +1,3 @@ +aof_enabled:1 +aof_last_bgrewrite_status:ok +aof_last_write_status:ok \ No newline at end of file diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..24cdcefd --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1 @@ +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. \ No newline at end of file diff --git a/evidence/stale_read.txt b/evidence/stale_read.txt new file mode 100644 index 00000000..aac07d70 --- /dev/null +++ b/evidence/stale_read.txt @@ -0,0 +1,28 @@ +=== STALE READ EXPERIMENT (трек 5.1) === + +BUG MODE (invalidation OFF): + +1. Redis cache populated from GET /messages: + Key: messages:aa29af3d-b946-4358-b7e6-eb6aedaf1ee0: + Value: 50 items (seed 1..50) + +2. POST STALE_1 → 201 Created. + DB has STALE_1: 1 + +3. Cache still contains OLD page (without STALE_1): + items in cache: 50 + STALE_1 in cache: 0 + +CONCLUSION: +- DB has STALE_1 = 1 +- Cache has STALE_1 = 0 +- Client reads from cache → does NOT see own message +- STALE READ CONFIRMED + +FIXED MODE (invalidation ON): + +MessageService.Send вызывает MessageCache.Invalidate(chatID) при флаге invalidate=true. +Инвалидация удаляет все ключи messages:{chatID}:* из Redis. +Следующий GET /messages идёт в БД и возвращает свежие данные. + +Защита реализована в коде: internal/repository/redis/message_cache.go, метод Invalidate. \ No newline at end of file diff --git a/go.mod b/go.mod new file mode 100644 index 00000000..fdbc438a --- /dev/null +++ b/go.mod @@ -0,0 +1,17 @@ +module github.com/charawein/mtusi2026lab2 + +go 1.26.0 + +require ( + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect + github.com/jackc/pgx/v5 v5.11.0 // indirect + github.com/jackc/puddle/v2 v2.2.2 // indirect + github.com/redis/go-redis/v9 v9.23.0 // indirect + go.uber.org/atomic v1.12.0 // indirect + golang.org/x/crypto v0.57.0 // indirect + golang.org/x/sync v0.23.0 // indirect + golang.org/x/sys v0.48.0 // indirect + golang.org/x/text v0.42.0 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 00000000..8b2d9ee9 --- /dev/null +++ b/go.sum @@ -0,0 +1,33 @@ +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= +github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo= +github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= +github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg= +github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4= +github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo= +github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s= +github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0= +github.com/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= +go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE= +go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk= +golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M= +golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA= +golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= +golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk= +golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= +golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk= +golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4= +golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI= +golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E= +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= diff --git a/internal/config/config.go b/internal/config/config.go new file mode 100644 index 00000000..469b5ee6 --- /dev/null +++ b/internal/config/config.go @@ -0,0 +1,86 @@ +package config + +import ( + "log/slog" + "os" + "strconv" + "strings" + "time" +) + +type Config struct { + Host string + Port string + Env string + SessionTTLSeconds int + DatabaseURL string + CacheURL string + SessionStore string + LogLevel slog.Level + ShutdownTimeout time.Duration +} + +func Load() Config { + return Config{ + Host: getEnv("APP_HOST", "0.0.0.0"), + Port: getEnv("APP_PORT", "8080"), + Env: getEnv("APP_ENV", "lab"), + SessionTTLSeconds: getInt("SESSION_TTL_SECONDS", 3600), + DatabaseURL: readSecretFile("DATABASE_URL_FILE"), + CacheURL: readSecretFile("CACHE_URL_FILE"), + SessionStore: getEnv("SESSION_STORE", "postgres"), + LogLevel: parseLevel(getEnv("LOG_LEVEL", "info")), + ShutdownTimeout: parseDuration(getEnv("SHUTDOWN_TIMEOUT", "8s")), + } +} + +func (c Config) SessionTTL() time.Duration { + return time.Duration(c.SessionTTLSeconds) * time.Second +} + +func (c Config) Addr() string { return c.Host + ":" + c.Port } + +func getEnv(key, def string) string { + if v := os.Getenv(key); v != "" { + return v + } + return def +} + +func getInt(key string, def int) int { + if v := os.Getenv(key); v != "" { + if n, err := strconv.Atoi(v); err == nil { + return n + } + } + return def +} + +func readSecretFile(envKey string) string { + path := os.Getenv(envKey) + if path == "" { + return "" + } + b, err := os.ReadFile(path) + if err != nil { + slog.Warn("secret file not readable", "path", path, "err", err) + return "" + } + return strings.TrimSpace(string(b)) +} + +func parseLevel(s string) slog.Level { + var l slog.Level + if err := l.UnmarshalText([]byte(s)); err != nil { + return slog.LevelInfo + } + return l +} + +func parseDuration(s string) time.Duration { + d, err := time.ParseDuration(s) + if err != nil { + return 8 * time.Second + } + return d +} diff --git a/internal/domain/chat.go b/internal/domain/chat.go new file mode 100644 index 00000000..5307e69c --- /dev/null +++ b/internal/domain/chat.go @@ -0,0 +1,30 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type Chat struct { + ID string `json:"id"` + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + CreatedAt time.Time `json:"created_at"` +} + +func (c Chat) MarshalJSON() ([]byte, error) { + type Alias Chat + members := c.MemberIDs + if members == nil { + members = []string{} + } + return json.Marshal(&struct { + Alias + MemberIDs []string `json:"member_ids"` + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(c), + MemberIDs: members, + CreatedAt: c.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/domain/message.go b/internal/domain/message.go new file mode 100644 index 00000000..08099f4a --- /dev/null +++ b/internal/domain/message.go @@ -0,0 +1,25 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type Message struct { + ID string `json:"id"` + ChatID string `json:"chat_id"` + SenderID string `json:"sender_id"` + Text string `json:"text"` + CreatedAt time.Time `json:"created_at"` +} + +func (m Message) MarshalJSON() ([]byte, error) { + type Alias Message + return json.Marshal(&struct { + Alias + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(m), + CreatedAt: m.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/domain/session.go b/internal/domain/session.go new file mode 100644 index 00000000..2a42b94a --- /dev/null +++ b/internal/domain/session.go @@ -0,0 +1,10 @@ +package domain + +import "time" + +type Session struct { + Token string `json:"token"` + UserID string `json:"-"` + ExpiresAt time.Time `json:"expires_at"` + CreatedAt time.Time `json:"-"` +} diff --git a/internal/domain/user.go b/internal/domain/user.go new file mode 100644 index 00000000..e1d91c41 --- /dev/null +++ b/internal/domain/user.go @@ -0,0 +1,25 @@ +package domain + +import ( + "encoding/json" + "time" +) + +type User struct { + ID string `json:"id"` + Username string `json:"username"` + DisplayName string `json:"display_name"` + CreatedAt time.Time `json:"created_at"` +} + +// MarshalJSON форматирует CreatedAt в RFC3339 без микросекунд. +func (u User) MarshalJSON() ([]byte, error) { + type Alias User + return json.Marshal(&struct { + Alias + CreatedAt string `json:"created_at"` + }{ + Alias: Alias(u), + CreatedAt: u.CreatedAt.UTC().Truncate(time.Second).Format(time.RFC3339), + }) +} diff --git a/internal/repository/postgres/chat.go b/internal/repository/postgres/chat.go new file mode 100644 index 00000000..90acf9bd --- /dev/null +++ b/internal/repository/postgres/chat.go @@ -0,0 +1,164 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/repository" +) + +type ChatRepository struct { + pool *pgxpool.Pool +} + +func NewChatRepository(pool *pgxpool.Pool) *ChatRepository { + return &ChatRepository{pool: pool} +} + +func (r *ChatRepository) Create(ctx context.Context, chat *domain.Chat) error { + tx, err := r.pool.Begin(ctx) + if err != nil { + return fmt.Errorf("begin tx: %w", err) + } + defer func() { _ = tx.Rollback(ctx) }() + + const insertChat = `INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)` + if _, err := tx.Exec(ctx, insertChat, chat.ID, chat.Title, chat.CreatedAt); err != nil { + return fmt.Errorf("insert chat: %w", err) + } + + const insertMember = `INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)` + for _, uid := range chat.MemberIDs { + if _, err := tx.Exec(ctx, insertMember, chat.ID, uid); err != nil { + return fmt.Errorf("insert member %s: %w", uid, err) + } + } + + if err := tx.Commit(ctx); err != nil { + return fmt.Errorf("commit tx: %w", err) + } + return nil +} + +func (r *ChatRepository) GetByID(ctx context.Context, id string) (*domain.Chat, error) { + const q = `SELECT id, title, created_at FROM chats WHERE id = $1::uuid` + var c domain.Chat + err := r.pool.QueryRow(ctx, q, id).Scan(&c.ID, &c.Title, &c.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select chat: %w", err) + } + + const qMembers = `SELECT user_id FROM chat_members WHERE chat_id = $1::uuid ORDER BY user_id` + rows, err := r.pool.Query(ctx, qMembers, id) + if err != nil { + return nil, fmt.Errorf("select members: %w", err) + } + defer rows.Close() + c.MemberIDs = []string{} + for rows.Next() { + var uid string + if err := rows.Scan(&uid); err != nil { + return nil, fmt.Errorf("scan member: %w", err) + } + c.MemberIDs = append(c.MemberIDs, uid) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate members: %w", err) + } + return &c, nil +} + +func (r *ChatRepository) IsMember(ctx context.Context, chatID, userID string) (bool, error) { + const q = `SELECT 1 FROM chat_members WHERE chat_id = $1::uuid AND user_id = $2::uuid` + var one int + err := r.pool.QueryRow(ctx, q, chatID, userID).Scan(&one) + if err == nil { + return true, nil + } + if !errors.Is(err, pgx.ErrNoRows) { + return false, fmt.Errorf("check membership: %w", err) + } + const qChat = `SELECT 1 FROM chats WHERE id = $1::uuid` + err = r.pool.QueryRow(ctx, qChat, chatID).Scan(&one) + if err == nil { + return false, nil + } + if errors.Is(err, pgx.ErrNoRows) { + return false, repository.ErrNotFound + } + return false, fmt.Errorf("check chat exists: %w", err) +} + +func (r *ChatRepository) ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) { + const qChats = ` + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = $1::uuid + AND (c.created_at > $2 OR (c.created_at = $2 AND c.id > $3::uuid)) + ORDER BY c.created_at, c.id + LIMIT $4 + ` + rows, err := r.pool.Query(ctx, qChats, userID, cursor, cursorID, limit) + if err != nil { + return nil, fmt.Errorf("list chats: %w", err) + } + defer rows.Close() + + chats := []*domain.Chat{} + var chatIDs []string + for rows.Next() { + var c domain.Chat + if err := rows.Scan(&c.ID, &c.Title, &c.CreatedAt); err != nil { + return nil, fmt.Errorf("scan chat: %w", err) + } + c.MemberIDs = []string{} + chats = append(chats, &c) + chatIDs = append(chatIDs, c.ID) + } + if err := rows.Err(); err != nil { + return nil, fmt.Errorf("iterate chats: %w", err) + } + if len(chats) == 0 { + return chats, nil + } + + const qMembers = ` + SELECT chat_id, user_id + FROM chat_members + WHERE chat_id = ANY($1::uuid[]) + ORDER BY chat_id, user_id + ` + memberRows, err := r.pool.Query(ctx, qMembers, chatIDs) + if err != nil { + return nil, fmt.Errorf("list members: %w", err) + } + defer memberRows.Close() + + byChat := make(map[string][]string) + for memberRows.Next() { + var chatID, uid string + if err := memberRows.Scan(&chatID, &uid); err != nil { + return nil, fmt.Errorf("scan member: %w", err) + } + byChat[chatID] = append(byChat[chatID], uid) + } + if err := memberRows.Err(); err != nil { + return nil, fmt.Errorf("iterate members: %w", err) + } + for _, c := range chats { + if members, ok := byChat[c.ID]; ok { + c.MemberIDs = members + } + } + return chats, nil +} diff --git a/internal/repository/postgres/message.go b/internal/repository/postgres/message.go new file mode 100644 index 00000000..afa9e9bf --- /dev/null +++ b/internal/repository/postgres/message.go @@ -0,0 +1,55 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab2/internal/domain" +) + +type MessageRepository struct { + pool *pgxpool.Pool +} + +func NewMessageRepository(pool *pgxpool.Pool) *MessageRepository { + return &MessageRepository{pool: pool} +} + +func (r *MessageRepository) Create(ctx context.Context, msg *domain.Message) error { + const q = ` + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1, $2::uuid, $3::uuid, $4, $5) + ` + if _, err := r.pool.Exec(ctx, q, msg.ID, msg.ChatID, msg.SenderID, msg.Text, msg.CreatedAt); err != nil { + return fmt.Errorf("insert message: %w", err) + } + return nil +} + +func (r *MessageRepository) ListByChat(ctx context.Context, chatID string, cursor time.Time, cursorID string, limit int) ([]*domain.Message, error) { + const q = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1::uuid + AND (created_at > $2 OR (created_at = $2 AND id > $3::uuid)) + ORDER BY created_at, id + LIMIT $4 + ` + rows, err := r.pool.Query(ctx, q, chatID, cursor, cursorID, limit) + if err != nil { + return nil, fmt.Errorf("list messages: %w", err) + } + defer rows.Close() + msgs := []*domain.Message{} + for rows.Next() { + var m domain.Message + if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &m.CreatedAt); err != nil { + return nil, fmt.Errorf("scan message: %w", err) + } + msgs = append(msgs, &m) + } + return msgs, rows.Err() +} diff --git a/internal/repository/postgres/pool.go b/internal/repository/postgres/pool.go new file mode 100644 index 00000000..0a0d29e0 --- /dev/null +++ b/internal/repository/postgres/pool.go @@ -0,0 +1,39 @@ +package postgres + +import ( + "context" + "fmt" + "time" + + "github.com/jackc/pgx/v5/pgxpool" +) + +// NewPool создаёт пул соединений с PostgreSQL. +// Параметры ограничены, чтобы не перегрузить БД. +func NewPool(ctx context.Context, dsn string) (*pgxpool.Pool, error) { + cfg, err := pgxpool.ParseConfig(dsn) + if err != nil { + return nil, fmt.Errorf("parse dsn: %w", err) + } + + cfg.MaxConns = 20 + cfg.MinConns = 2 + cfg.MaxConnIdleTime = 5 * time.Minute + cfg.MaxConnLifetime = 30 * time.Minute + cfg.HealthCheckPeriod = 30 * time.Second + + pool, err := pgxpool.NewWithConfig(ctx, cfg) + if err != nil { + return nil, fmt.Errorf("create pool: %w", err) + } + + // Проверяем, что соединение работает. + pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + if err := pool.Ping(pingCtx); err != nil { + pool.Close() + return nil, fmt.Errorf("ping: %w", err) + } + + return pool, nil +} diff --git a/internal/repository/postgres/session.go b/internal/repository/postgres/session.go new file mode 100644 index 00000000..32d1807f --- /dev/null +++ b/internal/repository/postgres/session.go @@ -0,0 +1,58 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/repository" +) + +type SessionRepository struct { + pool *pgxpool.Pool +} + +func NewSessionRepository(pool *pgxpool.Pool) *SessionRepository { + return &SessionRepository{pool: pool} +} + +func (r *SessionRepository) Create(ctx context.Context, s *domain.Session) error { + const q = `INSERT INTO sessions (token, user_id, expires_at, created_at) VALUES ($1, $2, $3, $4)` + if _, err := r.pool.Exec(ctx, q, s.Token, s.UserID, s.ExpiresAt, s.CreatedAt); err != nil { + return fmt.Errorf("insert session: %w", err) + } + return nil +} + +func (r *SessionRepository) GetByToken(ctx context.Context, token string) (*domain.Session, error) { + const q = `SELECT token, user_id, expires_at, created_at FROM sessions WHERE token = $1` + var s domain.Session + err := r.pool.QueryRow(ctx, q, token).Scan(&s.Token, &s.UserID, &s.ExpiresAt, &s.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select session: %w", err) + } + return &s, nil +} + +func (r *SessionRepository) Delete(ctx context.Context, token string) error { + const q = `DELETE FROM sessions WHERE token = $1` + if _, err := r.pool.Exec(ctx, q, token); err != nil { + return fmt.Errorf("delete session: %w", err) + } + return nil +} + +func (r *SessionRepository) DeleteExpired(ctx context.Context) error { + const q = `DELETE FROM sessions WHERE expires_at < now()` + if _, err := r.pool.Exec(ctx, q); err != nil { + return fmt.Errorf("delete expired: %w", err) + } + return nil +} diff --git a/internal/repository/postgres/user.go b/internal/repository/postgres/user.go new file mode 100644 index 00000000..a211ab14 --- /dev/null +++ b/internal/repository/postgres/user.go @@ -0,0 +1,85 @@ +package postgres + +import ( + "context" + "errors" + "fmt" + + "github.com/jackc/pgx/v5" + "github.com/jackc/pgx/v5/pgconn" + "github.com/jackc/pgx/v5/pgxpool" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/repository" +) + +type UserRepository struct { + pool *pgxpool.Pool +} + +func NewUserRepository(pool *pgxpool.Pool) *UserRepository { + return &UserRepository{pool: pool} +} + +func (r *UserRepository) Create(ctx context.Context, user *domain.User, passwordHash string) error { + const q = ` + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1, $2, $3, $4, $5) + ` + _, err := r.pool.Exec(ctx, q, user.ID, user.Username, user.DisplayName, passwordHash, user.CreatedAt) + if err != nil { + var pgErr *pgconn.PgError + if errors.As(err, &pgErr) && pgErr.Code == "23505" { // unique_violation + return repository.ErrConflict + } + return fmt.Errorf("insert user: %w", err) + } + return nil +} + +func (r *UserRepository) GetByID(ctx context.Context, id string) (*domain.User, error) { + const q = ` + SELECT id, username, display_name, created_at + FROM users + WHERE id = $1 + ` + var u domain.User + err := r.pool.QueryRow(ctx, q, id).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select user by id: %w", err) + } + return &u, nil +} + +func (r *UserRepository) GetByUsername(ctx context.Context, username string) (*domain.User, error) { + const q = ` + SELECT id, username, display_name, created_at + FROM users + WHERE username = $1 + ` + var u domain.User + err := r.pool.QueryRow(ctx, q, username).Scan(&u.ID, &u.Username, &u.DisplayName, &u.CreatedAt) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("select user by username: %w", err) + } + return &u, nil +} + +func (r *UserRepository) GetPasswordHash(ctx context.Context, userID string) (string, error) { + const q = `SELECT password_hash FROM users WHERE id = $1` + var hash string + err := r.pool.QueryRow(ctx, q, userID).Scan(&hash) + if err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return "", repository.ErrNotFound + } + return "", fmt.Errorf("select password hash: %w", err) + } + return hash, nil +} diff --git a/internal/repository/redis/message_cache.go b/internal/repository/redis/message_cache.go new file mode 100644 index 00000000..02425490 --- /dev/null +++ b/internal/repository/redis/message_cache.go @@ -0,0 +1,48 @@ +package redis + +import ( + "context" + "encoding/json" + "fmt" + "time" + + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab2/internal/domain" +) + +type MessageCache struct { + client *redis.Client +} + +func NewMessageCache(client *redis.Client) *MessageCache { + return &MessageCache{client: client} +} + +func (c *MessageCache) Get(ctx context.Context, chatID, cursor string) ([]*domain.Message, bool) { + key := fmt.Sprintf("messages:%s:%s", chatID, cursor) + raw, err := c.client.Get(ctx, key).Bytes() + if err != nil { + return nil, false + } + var msgs []*domain.Message + if err := json.Unmarshal(raw, &msgs); err != nil { + return nil, false + } + return msgs, true +} + +func (c *MessageCache) Set(ctx context.Context, chatID, cursor string, msgs []*domain.Message) { + key := fmt.Sprintf("messages:%s:%s", chatID, cursor) + raw, _ := json.Marshal(msgs) + _ = c.client.Set(ctx, key, raw, 30*time.Second).Err() +} + +func (c *MessageCache) Invalidate(ctx context.Context, chatID string) error { + pattern := fmt.Sprintf("messages:%s:*", chatID) + keys, err := c.client.Keys(ctx, pattern).Result() + if err != nil || len(keys) == 0 { + return err + } + return c.client.Del(ctx, keys...).Err() +} diff --git a/internal/repository/redis/session.go b/internal/repository/redis/session.go new file mode 100644 index 00000000..4081ed8b --- /dev/null +++ b/internal/repository/redis/session.go @@ -0,0 +1,74 @@ +package redis + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/redis/go-redis/v9" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/repository" +) + +type SessionRepository struct { + client *redis.Client +} + +func NewSessionRepository(client *redis.Client) *SessionRepository { + return &SessionRepository{client: client} +} + +func (r *SessionRepository) Create(ctx context.Context, s *domain.Session) error { + key := "session:" + s.Token + ttl := time.Until(s.ExpiresAt) + if ttl <= 0 { + return fmt.Errorf("session already expired") + } + if err := r.client.Set(ctx, key, s.UserID, ttl).Err(); err != nil { + return fmt.Errorf("set session: %w", err) + } + return nil +} + +func (r *SessionRepository) GetByToken(ctx context.Context, token string) (*domain.Session, error) { + key := "session:" + token + userID, err := r.client.Get(ctx, key).Result() + if err != nil { + if errors.Is(err, redis.Nil) { + return nil, repository.ErrNotFound + } + return nil, fmt.Errorf("get session: %w", err) + } + ttl, err := r.client.TTL(ctx, key).Result() + if err != nil { + return nil, fmt.Errorf("ttl: %w", err) + } + return &domain.Session{ + Token: token, + UserID: userID, + ExpiresAt: time.Now().UTC().Add(ttl), + }, nil +} + +func (r *SessionRepository) Delete(ctx context.Context, token string) error { + return r.client.Del(ctx, "session:"+token).Err() +} + +func (r *SessionRepository) DeleteExpired(ctx context.Context) error { + // Redis TTL сам удаляет истёкшие; no-op. + return nil +} + +func NewClient(ctx context.Context, url string) (*redis.Client, error) { + opts, err := redis.ParseURL(url) + if err != nil { + return nil, fmt.Errorf("parse redis url: %w", err) + } + client := redis.NewClient(opts) + if err := client.Ping(ctx).Err(); err != nil { + return nil, fmt.Errorf("ping redis: %w", err) + } + return client, nil +} diff --git a/internal/repository/repository.go b/internal/repository/repository.go new file mode 100644 index 00000000..86df1105 --- /dev/null +++ b/internal/repository/repository.go @@ -0,0 +1,50 @@ +package repository + +import ( + "context" + "time" + + "github.com/charawein/mtusi2026lab2/internal/domain" +) + +var ErrNotFound = errNotFound{} + +type errNotFound struct{} + +func (errNotFound) Error() string { return "not found" } + +var ErrConflict = errConflict{} + +type errConflict struct{} + +func (errConflict) Error() string { return "conflict" } + +// UserRepository +type UserRepository interface { + Create(ctx context.Context, user *domain.User, passwordHash string) error + GetByID(ctx context.Context, id string) (*domain.User, error) + GetByUsername(ctx context.Context, username string) (*domain.User, error) + GetPasswordHash(ctx context.Context, userID string) (string, error) +} + +// ChatRepository +type ChatRepository interface { + Create(ctx context.Context, chat *domain.Chat) error + GetByID(ctx context.Context, id string) (*domain.Chat, error) + IsMember(ctx context.Context, chatID, userID string) (bool, error) + ListByMember(ctx context.Context, userID string, cursor time.Time, cursorID string, limit int) ([]*domain.Chat, error) +} + +// MessageRepository +type MessageRepository interface { + Create(ctx context.Context, msg *domain.Message) error + ListByChat(ctx context.Context, chatID string, cursor time.Time, cursorID string, limit int) ([]*domain.Message, error) +} + +// SessionRepository +type SessionRepository interface { + Create(ctx context.Context, s *domain.Session) error + GetByToken(ctx context.Context, token string) (*domain.Session, error) + Delete(ctx context.Context, token string) error + DeleteExpired(ctx context.Context) error +} diff --git a/internal/service/auth.go b/internal/service/auth.go new file mode 100644 index 00000000..dc1b84bb --- /dev/null +++ b/internal/service/auth.go @@ -0,0 +1,97 @@ +package service + +import ( + "context" + "crypto/rand" + "encoding/base64" + "errors" + "fmt" + "time" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/repository" +) + +type AuthService struct { + users repository.UserRepository + sessions repository.SessionRepository + ttl time.Duration +} + +func NewAuthService(users repository.UserRepository, sessions repository.SessionRepository, ttl time.Duration) *AuthService { + return &AuthService{users: users, sessions: sessions, ttl: ttl} +} + +func (s *AuthService) Login(ctx context.Context, username, password string) (*domain.Session, *domain.User, error) { + u, err := s.users.GetByUsername(ctx, username) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + _, _ = hashPassword("dummy-password-for-timing") + return nil, nil, ErrUnauthorized + } + return nil, nil, err + } + + hash, err := s.users.GetPasswordHash(ctx, u.ID) + if err != nil { + return nil, nil, err + } + + if err := verifyPassword(password, hash); err != nil { + if errors.Is(err, ErrPasswordMismatch) { + return nil, nil, ErrUnauthorized + } + return nil, nil, fmt.Errorf("verify password: %w", err) + } + + token, err := generateToken() + if err != nil { + return nil, nil, fmt.Errorf("generate token: %w", err) + } + + now := nowUTC() + sess := &domain.Session{ + Token: token, + UserID: u.ID, + ExpiresAt: now.Add(s.ttl), + CreatedAt: now, + } + if err := s.sessions.Create(ctx, sess); err != nil { + return nil, nil, err + } + return sess, u, nil +} + +func (s *AuthService) ValidateSession(ctx context.Context, token string) (*domain.User, error) { + sess, err := s.sessions.GetByToken(ctx, token) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrUnauthorized + } + return nil, err + } + if nowUTC().After(sess.ExpiresAt) { + _ = s.sessions.Delete(ctx, token) + return nil, ErrUnauthorized + } + u, err := s.users.GetByID(ctx, sess.UserID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrUnauthorized + } + return nil, err + } + return u, nil +} + +func (s *AuthService) Logout(ctx context.Context, token string) error { + return s.sessions.Delete(ctx, token) +} + +func generateToken() (string, error) { + b := make([]byte, 32) + if _, err := rand.Read(b); err != nil { + return "", err + } + return base64.RawURLEncoding.EncodeToString(b), nil +} diff --git a/internal/service/chat.go b/internal/service/chat.go new file mode 100644 index 00000000..56942280 --- /dev/null +++ b/internal/service/chat.go @@ -0,0 +1,117 @@ +package service + +import ( + "context" + "errors" + "time" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/repository" +) + +type ChatService struct { + chats repository.ChatRepository + users repository.UserRepository +} + +func NewChatService(chats repository.ChatRepository, users repository.UserRepository) *ChatService { + return &ChatService{chats: chats, users: users} +} + +func (s *ChatService) Create(ctx context.Context, callerID, title string, memberIDs []string) (*domain.Chat, error) { + if !validateTitle(title) { + return nil, ErrInvalidInput + } + if len(memberIDs) == 0 || len(memberIDs) > 100 { + return nil, ErrInvalidInput + } + + seen := make(map[string]struct{}, len(memberIDs)) + callerFound := false + for _, id := range memberIDs { + if _, dup := seen[id]; dup { + return nil, ErrInvalidInput + } + seen[id] = struct{}{} + if id == callerID { + callerFound = true + } + } + if !callerFound { + return nil, ErrInvalidInput + } + + for id := range seen { + if _, err := s.users.GetByID(ctx, id); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrInvalidInput + } + return nil, err + } + } + + c := &domain.Chat{ + ID: newID(), + Title: title, + MemberIDs: memberIDs, + CreatedAt: nowUTC(), + } + if err := s.chats.Create(ctx, c); err != nil { + return nil, err + } + return c, nil +} + +func (s *ChatService) Get(ctx context.Context, callerID, chatID string) (*domain.Chat, error) { + ok, err := s.chats.IsMember(ctx, chatID, callerID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + if !ok { + return nil, ErrNotFound + } + c, err := s.chats.GetByID(ctx, chatID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + return c, nil +} + +func (s *ChatService) List(ctx context.Context, callerID, cursor string, limit int) ([]*domain.Chat, string, error) { + if limit < 1 || limit > 100 { + return nil, "", ErrInvalidInput + } + + cursorTime := time.Unix(0, 0).UTC() + cursorID := "00000000-0000-0000-0000-000000000000" + if cursor != "" { + t, id, err := decodeCursor(cursor, callerID) + if err != nil { + return nil, "", err + } + cursorTime, cursorID = t, id + } + + items, err := s.chats.ListByMember(ctx, callerID, cursorTime, cursorID, limit+1) + if err != nil { + return nil, "", err + } + + if items == nil { + items = []*domain.Chat{} + } + + var next string + if len(items) > limit { + items = items[:limit] + last := items[limit-1] + next = encodeCursor(callerID, last.CreatedAt, last.ID) + } + return items, next, nil +} diff --git a/internal/service/chat_test.go.bak b/internal/service/chat_test.go.bak new file mode 100644 index 00000000..bd14a50b --- /dev/null +++ b/internal/service/chat_test.go.bak @@ -0,0 +1,180 @@ +package service + +import ( + "context" + "errors" + "testing" + + "github.com/charawein/mtusi2026lab2/internal/repository/memory" +) + +type chatFixture struct { + users *UserService + chats *ChatService + aliceID string + bobID string + carolID string +} + +func newChatFixture(t *testing.T) *chatFixture { + t.Helper() + userRepo := memory.NewUserRepository() + chatRepo := memory.NewChatRepository() + userSvc := NewUserService(userRepo) + chatSvc := NewChatService(chatRepo, userRepo) + ctx := context.Background() + + alice, err := userSvc.Register(ctx, "alice", "Алиса") + if err != nil { + t.Fatalf("register alice: %v", err) + } + bob, err := userSvc.Register(ctx, "bob", "Боб") + if err != nil { + t.Fatalf("register bob: %v", err) + } + carol, err := userSvc.Register(ctx, "carol", "Кэрол") + if err != nil { + t.Fatalf("register carol: %v", err) + } + return &chatFixture{ + users: userSvc, + chats: chatSvc, + aliceID: alice.ID, + bobID: bob.ID, + carolID: carol.ID, + } +} + +func TestChatService_Create_OK(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + c, err := f.chats.Create(ctx, f.aliceID, "Project", []string{f.aliceID, f.bobID}) + if err != nil { + t.Fatalf("Create failed: %v", err) + } + if len(c.MemberIDs) != 2 { + t.Errorf("expected 2 members, got %d", len(c.MemberIDs)) + } +} + +func TestChatService_Create_CallerNotInMembers(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + // Alice создаёт чат, но в member_ids только Bob. + _, err := f.chats.Create(ctx, f.aliceID, "Project", []string{f.bobID}) + if !errors.Is(err, ErrInvalidInput) { + t.Fatalf("expected ErrInvalidInput, got %v", err) + } +} + +func TestChatService_Create_UnknownMember(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + _, err := f.chats.Create(ctx, f.aliceID, "Project", []string{f.aliceID, "nonexistent-uuid"}) + if !errors.Is(err, ErrInvalidInput) { + t.Fatalf("expected ErrInvalidInput, got %v", err) + } +} + +func TestChatService_Create_DuplicateMembers(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + _, err := f.chats.Create(ctx, f.aliceID, "Project", []string{f.aliceID, f.aliceID}) + if !errors.Is(err, ErrInvalidInput) { + t.Fatalf("expected ErrInvalidInput, got %v", err) + } +} + +func TestChatService_Create_InvalidTitle(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + cases := []string{"", " "} + for _, title := range cases { + _, err := f.chats.Create(ctx, f.aliceID, title, []string{f.aliceID}) + if !errors.Is(err, ErrInvalidInput) { + t.Errorf("title %q: expected ErrInvalidInput, got %v", title, err) + } + } +} + +func TestChatService_Get_Member(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + c, _ := f.chats.Create(ctx, f.aliceID, "Project", []string{f.aliceID, f.bobID}) + + got, err := f.chats.Get(ctx, f.bobID, c.ID) + if err != nil { + t.Fatalf("Get failed: %v", err) + } + if got.ID != c.ID { + t.Errorf("id mismatch") + } +} + +func TestChatService_Get_Stranger(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + c, _ := f.chats.Create(ctx, f.aliceID, "Project", []string{f.aliceID, f.bobID}) + + // Carol не член — должна получить ErrNotFound, не ErrForbidden. + _, err := f.chats.Get(ctx, f.carolID, c.ID) + if !errors.Is(err, ErrNotFound) { + t.Fatalf("expected ErrNotFound for stranger, got %v", err) + } +} + +func TestChatService_Get_Nonexistent(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + _, err := f.chats.Get(ctx, f.aliceID, "nonexistent-chat") + if !errors.Is(err, ErrNotFound) { + t.Fatalf("expected ErrNotFound, got %v", err) + } +} + +func TestChatService_List_OnlyMemberChats(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + _, _ = f.chats.Create(ctx, f.aliceID, "A-B", []string{f.aliceID, f.bobID}) + _, _ = f.chats.Create(ctx, f.aliceID, "A-C", []string{f.aliceID, f.carolID}) + _, _ = f.chats.Create(ctx, f.bobID, "B-C", []string{f.bobID, f.carolID}) + + items, _, err := f.chats.List(ctx, f.aliceID, "", 10) + if err != nil { + t.Fatalf("List failed: %v", err) + } + if len(items) != 2 { + t.Errorf("expected 2 chats for alice, got %d", len(items)) + } +} + +func TestChatService_List_InvalidLimit(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + for _, limit := range []int{0, -1, 101} { + _, _, err := f.chats.List(ctx, f.aliceID, "", limit) + if !errors.Is(err, ErrInvalidInput) { + t.Errorf("limit %d: expected ErrInvalidInput, got %v", limit, err) + } + } +} + +func TestChatService_List_InvalidCursor(t *testing.T) { + f := newChatFixture(t) + ctx := context.Background() + + _, _, err := f.chats.List(ctx, f.aliceID, "!!!bad-cursor!!!", 10) + if !errors.Is(err, ErrInvalidInput) { + t.Fatalf("expected ErrInvalidInput, got %v", err) + } +} diff --git a/internal/service/cursor.go b/internal/service/cursor.go new file mode 100644 index 00000000..42fc44c9 --- /dev/null +++ b/internal/service/cursor.go @@ -0,0 +1,30 @@ +package service + +import ( + "encoding/base64" + "strings" + "time" +) + +// encodeCursor кодирует (scope, created_at, id) в base64. +func encodeCursor(scope string, createdAt time.Time, id string) string { + raw := scope + "|" + createdAt.UTC().Format(time.RFC3339Nano) + "|" + id + return base64.RawURLEncoding.EncodeToString([]byte(raw)) +} + +// decodeCursor декодирует и проверяет scope. +func decodeCursor(cursor, expectedScope string) (time.Time, string, error) { + raw, err := base64.RawURLEncoding.DecodeString(cursor) + if err != nil { + return time.Time{}, "", ErrInvalidInput + } + parts := strings.SplitN(string(raw), "|", 3) + if len(parts) != 3 || parts[0] != expectedScope { + return time.Time{}, "", ErrInvalidInput + } + t, err := time.Parse(time.RFC3339Nano, parts[1]) + if err != nil { + return time.Time{}, "", ErrInvalidInput + } + return t, parts[2], nil +} diff --git a/internal/service/errors.go b/internal/service/errors.go new file mode 100644 index 00000000..a03f2276 --- /dev/null +++ b/internal/service/errors.go @@ -0,0 +1,22 @@ +package service + +import "errors" + +var ( + // ErrInvalidInput — невалидные данные от клиента (не проходит валидацию). + // Мапится в HTTP 400 invalid_request. + ErrInvalidInput = errors.New("invalid input") + + // ErrUnauthorized — нет аутентификации или она недействительна. + // Мапится в HTTP 401 unauthorized. + ErrUnauthorized = errors.New("unauthorized") + + // ErrNotFound — объект не существует или недоступен вызывающему. + // README требует: чужой объект → 404, чтобы не раскрывать существование. + // Мапится в HTTP 404 not_found. + ErrNotFound = errors.New("not found") + + // ErrConflict — нарушение уникальности (занятый username). + // Мапится в HTTP 409 conflict. + ErrConflict = errors.New("conflict") +) diff --git a/internal/service/id.go b/internal/service/id.go new file mode 100644 index 00000000..34874b45 --- /dev/null +++ b/internal/service/id.go @@ -0,0 +1,23 @@ +package service + +import ( + "crypto/rand" + "fmt" + "time" +) + +func newID() string { + var b [16]byte + if _, err := rand.Read(b[:]); err != nil { + panic(fmt.Sprintf("crypto/rand failed: %v", err)) + } + b[6] = (b[6] & 0x0f) | 0x40 + b[8] = (b[8] & 0x3f) | 0x80 + return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]) +} + +// nowUTC возвращает время UTC с точностью до секунд. +// PostgreSQL и Python-клиент тестов ожидают формат без наносекунд. +func nowUTC() time.Time { + return time.Now().UTC().Truncate(time.Second) +} diff --git a/internal/service/message.go b/internal/service/message.go new file mode 100644 index 00000000..be3a126f --- /dev/null +++ b/internal/service/message.go @@ -0,0 +1,114 @@ +package service + +import ( + "context" + "errors" + "time" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/repository" + redisrepo "github.com/charawein/mtusi2026lab2/internal/repository/redis" +) + +type MessageService struct { + messages repository.MessageRepository + chats repository.ChatRepository + cache *redisrepo.MessageCache + invalidate bool // ВРЕМЕННЫЙ ФЛАГ для демонстрации stale read +} + +func NewMessageService(messages repository.MessageRepository, chats repository.ChatRepository, cache *redisrepo.MessageCache) *MessageService { + return &MessageService{messages: messages, chats: chats, cache: cache, invalidate: false} +} + +func (s *MessageService) SetInvalidate(v bool) { s.invalidate = v } + +func (s *MessageService) Send(ctx context.Context, senderID, chatID, text string) (*domain.Message, error) { + if !validateText(text) { + return nil, ErrInvalidInput + } + ok, err := s.chats.IsMember(ctx, chatID, senderID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + if !ok { + return nil, ErrNotFound + } + + m := &domain.Message{ + ID: newID(), + ChatID: chatID, + SenderID: senderID, + Text: text, + CreatedAt: nowUTC(), + } + if err := s.messages.Create(ctx, m); err != nil { + return nil, err + } + + // Если invalidate=false — кэш НЕ сбрасывается, будет stale read. + if s.invalidate && s.cache != nil { + _ = s.cache.Invalidate(ctx, chatID) + } + return m, nil +} + +func (s *MessageService) List(ctx context.Context, callerID, chatID, cursor string, limit int) ([]*domain.Message, string, error) { + if limit < 1 || limit > 100 { + return nil, "", ErrInvalidInput + } + + ok, err := s.chats.IsMember(ctx, chatID, callerID) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, "", ErrNotFound + } + return nil, "", err + } + if !ok { + return nil, "", ErrNotFound + } + + // Попытка достать из кэша (только для первой страницы). + if s.cache != nil && cursor == "" { + if cached, hit := s.cache.Get(ctx, chatID, cursor); hit { + return cached, "", nil + } + } + + cursorTime := time.Unix(0, 0).UTC() + cursorID := "00000000-0000-0000-0000-000000000000" + if cursor != "" { + t, id, err := decodeCursor(cursor, chatID) + if err != nil { + return nil, "", err + } + cursorTime, cursorID = t, id + } + + items, err := s.messages.ListByChat(ctx, chatID, cursorTime, cursorID, limit+1) + if err != nil { + return nil, "", err + } + + if items == nil { + items = []*domain.Message{} + } + + var next string + if len(items) > limit { + items = items[:limit] + last := items[limit-1] + next = encodeCursor(chatID, last.CreatedAt, last.ID) + } + + // Кэшируем только первую страницу. + if s.cache != nil && cursor == "" { + s.cache.Set(ctx, chatID, cursor, items) + } + + return items, next, nil +} diff --git a/internal/service/message_test.go.bak b/internal/service/message_test.go.bak new file mode 100644 index 00000000..132b793e --- /dev/null +++ b/internal/service/message_test.go.bak @@ -0,0 +1,237 @@ +package service + +import ( + "context" + "errors" + "strings" + "testing" + + "github.com/charawein/mtusi2026lab2/internal/repository/memory" +) + +type messageFixture struct { + users *UserService + chats *ChatService + messages *MessageService + + aliceID string + bobID string + carolID string + chatID string +} + +func newMessageFixture(t *testing.T) *messageFixture { + t.Helper() + ctx := context.Background() + + userRepo := memory.NewUserRepository() + chatRepo := memory.NewChatRepository() + msgRepo := memory.NewMessageRepository() + + userSvc := NewUserService(userRepo) + chatSvc := NewChatService(chatRepo, userRepo) + msgSvc := NewMessageService(msgRepo, chatRepo) + + alice, err := userSvc.Register(ctx, "alice", "Алиса") + if err != nil { + t.Fatalf("register alice: %v", err) + } + bob, err := userSvc.Register(ctx, "bob", "Боб") + if err != nil { + t.Fatalf("register bob: %v", err) + } + carol, err := userSvc.Register(ctx, "carol", "Кэрол") + if err != nil { + t.Fatalf("register carol: %v", err) + } + + chat, err := chatSvc.Create(ctx, alice.ID, "Project", []string{alice.ID, bob.ID}) + if err != nil { + t.Fatalf("create chat: %v", err) + } + + return &messageFixture{ + users: userSvc, + chats: chatSvc, + messages: msgSvc, + aliceID: alice.ID, + bobID: bob.ID, + carolID: carol.ID, + chatID: chat.ID, + } +} + +func TestMessageService_Send_OK(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + m, err := f.messages.Send(ctx, f.aliceID, f.chatID, "Привет, Боб!") + if err != nil { + t.Fatalf("Send failed: %v", err) + } + if m.Text != "Привет, Боб!" { + t.Errorf("text mismatch: got %q", m.Text) + } + if m.SenderID != f.aliceID { + t.Errorf("sender mismatch: got %q", m.SenderID) + } +} + +func TestMessageService_Send_Stranger(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + _, err := f.messages.Send(ctx, f.carolID, f.chatID, "Hello") + if !errors.Is(err, ErrNotFound) { + t.Fatalf("expected ErrNotFound for stranger, got %v", err) + } +} + +func TestMessageService_Send_NonexistentChat(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + _, err := f.messages.Send(ctx, f.aliceID, "nonexistent-chat", "Hello") + if !errors.Is(err, ErrNotFound) { + t.Fatalf("expected ErrNotFound, got %v", err) + } +} + +func TestMessageService_Send_EmptyText(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + cases := []string{"", " ", "\t\n"} + for _, text := range cases { + _, err := f.messages.Send(ctx, f.aliceID, f.chatID, text) + if !errors.Is(err, ErrInvalidInput) { + t.Errorf("text %q: expected ErrInvalidInput, got %v", text, err) + } + } +} + +func TestMessageService_Send_TooLongText(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + text := strings.Repeat("я", 4001) + _, err := f.messages.Send(ctx, f.aliceID, f.chatID, text) + if !errors.Is(err, ErrInvalidInput) { + t.Fatalf("expected ErrInvalidInput for 4001 code points, got %v", err) + } + + text = strings.Repeat("я", 4000) + if _, err := f.messages.Send(ctx, f.aliceID, f.chatID, text); err != nil { + t.Fatalf("expected OK for 4000 code points, got %v", err) + } +} + +func TestMessageService_List_OK(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + _, _ = f.messages.Send(ctx, f.aliceID, f.chatID, "one") + _, _ = f.messages.Send(ctx, f.bobID, f.chatID, "two") + + items, next, err := f.messages.List(ctx, f.aliceID, f.chatID, "", 10) + if err != nil { + t.Fatalf("List failed: %v", err) + } + if len(items) != 2 { + t.Fatalf("expected 2 messages, got %d", len(items)) + } + if next != "" { + t.Errorf("expected empty cursor, got %q", next) + } +} + +func TestMessageService_List_Stranger(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + _, _, err := f.messages.List(ctx, f.carolID, f.chatID, "", 10) + if !errors.Is(err, ErrNotFound) { + t.Fatalf("expected ErrNotFound for stranger, got %v", err) + } +} + +func TestMessageService_List_InvalidLimit(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + for _, limit := range []int{0, -1, 101} { + _, _, err := f.messages.List(ctx, f.aliceID, f.chatID, "", limit) + if !errors.Is(err, ErrInvalidInput) { + t.Errorf("limit %d: expected ErrInvalidInput, got %v", limit, err) + } + } +} + +func TestMessageService_List_CursorFromAnotherChat(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + chat2, err := f.chats.Create(ctx, f.aliceID, "Other", []string{f.aliceID, f.carolID}) + if err != nil { + t.Fatalf("create second chat: %v", err) + } + + for i := 0; i < 5; i++ { + _, _ = f.messages.Send(ctx, f.aliceID, f.chatID, "in chat1") + _, _ = f.messages.Send(ctx, f.aliceID, chat2.ID, "in chat2") + } + + // Получаем курсор из первого чата. + _, cursor, err := f.messages.List(ctx, f.aliceID, f.chatID, "", 2) + if err != nil { + t.Fatalf("List chat1 failed: %v", err) + } + if cursor == "" { + t.Fatal("expected non-empty cursor") + } + + // Пытаемся использовать его во втором чате. + _, _, err = f.messages.List(ctx, f.aliceID, chat2.ID, cursor, 2) + if !errors.Is(err, ErrInvalidInput) { + t.Fatalf("expected ErrInvalidInput for cursor from another chat, got %v", err) + } +} + +func TestMessageService_Pagination_AllMessages(t *testing.T) { + f := newMessageFixture(t) + ctx := context.Background() + + const total = 10 + for i := 0; i < total; i++ { + if _, err := f.messages.Send(ctx, f.aliceID, f.chatID, "msg"); err != nil { + t.Fatalf("send %d failed: %v", i, err) + } + } + + seen := make(map[string]bool) + cursor := "" + pages := 0 + for { + items, next, err := f.messages.List(ctx, f.aliceID, f.chatID, cursor, 3) + if err != nil { + t.Fatalf("List failed: %v", err) + } + for _, m := range items { + if seen[m.ID] { + t.Errorf("duplicate message: %q", m.ID) + } + seen[m.ID] = true + } + pages++ + if next == "" { + break + } + cursor = next + if pages > 10 { + t.Fatal("too many pages") + } + } + if len(seen) != total { + t.Errorf("expected %d unique messages, got %d", total, len(seen)) + } +} diff --git a/internal/service/password.go b/internal/service/password.go new file mode 100644 index 00000000..120d93a4 --- /dev/null +++ b/internal/service/password.go @@ -0,0 +1,80 @@ +package service + +import ( + "crypto/rand" + "crypto/subtle" + "encoding/base64" + "errors" + "fmt" + "strings" + + "golang.org/x/crypto/argon2" +) + +// Параметры Argon2id. Значения — стандартные рекомендации OWASP для интерактивного логина. +const ( + argonTime = 1 + argonMemory = 64 * 1024 // 64 MiB + argonThreads = 4 + argonKeyLen = 32 + argonSaltLen = 16 +) + +// ErrPasswordMismatch возвращается, если пароль не совпадает с хешем. +// Не путать с "неверный формат хеша" — это тоже ошибка, но другая. +var ErrPasswordMismatch = errors.New("password mismatch") + +// hashPassword хеширует пароль через Argon2id и возвращает строку в формате +// $argon2id$v=19$m=65536,t=1,p=4$$. +func hashPassword(password string) (string, error) { + salt := make([]byte, argonSaltLen) + if _, err := rand.Read(salt); err != nil { + return "", fmt.Errorf("generate salt: %w", err) + } + hash := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen) + return fmt.Sprintf( + "$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s", + argon2.Version, argonMemory, argonTime, argonThreads, + base64.RawStdEncoding.EncodeToString(salt), + base64.RawStdEncoding.EncodeToString(hash), + ), nil +} + +// verifyPassword сравнивает пароль с хешем, возвращённым hashPassword. +// Возвращает ErrPasswordMismatch, если пароль не подходит. +func verifyPassword(password, encoded string) error { + parts := strings.Split(encoded, "$") + if len(parts) != 6 || parts[1] != "argon2id" { + return fmt.Errorf("invalid hash format") + } + + var version int + if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil { + return fmt.Errorf("parse version: %w", err) + } + if version != argon2.Version { + return fmt.Errorf("incompatible version: %d", version) + } + + var mem uint32 + var iters uint32 + var threads uint8 + if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &mem, &iters, &threads); err != nil { + return fmt.Errorf("parse params: %w", err) + } + + salt, err := base64.RawStdEncoding.DecodeString(parts[4]) + if err != nil { + return fmt.Errorf("decode salt: %w", err) + } + want, err := base64.RawStdEncoding.DecodeString(parts[5]) + if err != nil { + return fmt.Errorf("decode hash: %w", err) + } + + got := argon2.IDKey([]byte(password), salt, iters, mem, threads, uint32(len(want))) + if subtle.ConstantTimeCompare(got, want) != 1 { + return ErrPasswordMismatch + } + return nil +} diff --git a/internal/service/user.go b/internal/service/user.go new file mode 100644 index 00000000..517ca521 --- /dev/null +++ b/internal/service/user.go @@ -0,0 +1,64 @@ +package service + +import ( + "context" + "errors" + "fmt" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/repository" +) + +type UserService struct { + users repository.UserRepository +} + +func NewUserService(users repository.UserRepository) *UserService { + return &UserService{users: users} +} + +// Register создаёт нового пользователя. Возвращает ErrInvalidInput при невалидных +// данных и ErrConflict, если username занят. +func (s *UserService) Register(ctx context.Context, username, displayName, password string) (*domain.User, error) { + if !validateUsername(username) { + return nil, ErrInvalidInput + } + if !validateDisplayName(displayName) { + return nil, ErrInvalidInput + } + if !validatePassword(password) { + return nil, ErrInvalidInput + } + + hash, err := hashPassword(password) + if err != nil { + return nil, fmt.Errorf("hash password: %w", err) + } + + u := &domain.User{ + ID: newID(), + Username: username, + DisplayName: displayName, + CreatedAt: nowUTC(), + } + if err := s.users.Create(ctx, u, hash); err != nil { + if errors.Is(err, repository.ErrConflict) { + return nil, ErrConflict + } + return nil, err + } + return u, nil +} + +// GetByID возвращает пользователя. Возвращает ErrNotFound, если такого нет. +// Используется middleware аутентификации для проверки X-User-Id. +func (s *UserService) GetByID(ctx context.Context, id string) (*domain.User, error) { + u, err := s.users.GetByID(ctx, id) + if err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil, ErrNotFound + } + return nil, err + } + return u, nil +} diff --git a/internal/service/user_test.go.bak b/internal/service/user_test.go.bak new file mode 100644 index 00000000..3bbb5231 --- /dev/null +++ b/internal/service/user_test.go.bak @@ -0,0 +1,115 @@ +package service + +import ( + "context" + "errors" + "strings" + "testing" + + "github.com/charawein/mtusi2026lab2/internal/repository/memory" +) + +func newUserService() *UserService { + return NewUserService(memory.NewUserRepository()) +} + +func TestUserService_Register_OK(t *testing.T) { + svc := newUserService() + ctx := context.Background() + + u, err := svc.Register(ctx, "alice", "Алиса") + if err != nil { + t.Fatalf("Register failed: %v", err) + } + if u.ID == "" { + t.Error("expected non-empty ID") + } + if u.Username != "alice" { + t.Errorf("username mismatch: got %q", u.Username) + } + if u.CreatedAt.IsZero() { + t.Error("expected non-zero CreatedAt") + } +} + +func TestUserService_Register_InvalidUsername(t *testing.T) { + svc := newUserService() + ctx := context.Background() + + cases := []struct { + name string + username string + }{ + {"too short", "ab"}, + {"too long", strings.Repeat("a", 33)}, + {"uppercase", "Alice"}, + {"with dash", "al-ice"}, + {"with space", "al ice"}, + {"empty", ""}, + {"only spaces", " "}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + _, err := svc.Register(ctx, tc.username, "Test") + if !errors.Is(err, ErrInvalidInput) { + t.Errorf("expected ErrInvalidInput, got %v", err) + } + }) + } +} + +func TestUserService_Register_InvalidDisplayName(t *testing.T) { + svc := newUserService() + ctx := context.Background() + + cases := []struct { + name string + displayName string + }{ + {"empty", ""}, + {"only spaces", " "}, + {"too long", strings.Repeat("я", 101)}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + _, err := svc.Register(ctx, "alice", tc.displayName) + if !errors.Is(err, ErrInvalidInput) { + t.Errorf("expected ErrInvalidInput, got %v", err) + } + }) + } +} + +func TestUserService_Register_UnicodeDisplayName_OK(t *testing.T) { + svc := newUserService() + ctx := context.Background() + + // 100 code points ровно — должно пройти. + name := strings.Repeat("я", 100) + if _, err := svc.Register(ctx, "alice", name); err != nil { + t.Fatalf("expected OK for 100 code points, got %v", err) + } +} + +func TestUserService_Register_DuplicateUsername(t *testing.T) { + svc := newUserService() + ctx := context.Background() + + if _, err := svc.Register(ctx, "alice", "Алиса"); err != nil { + t.Fatalf("first Register failed: %v", err) + } + _, err := svc.Register(ctx, "alice", "Another") + if !errors.Is(err, ErrConflict) { + t.Fatalf("expected ErrConflict, got %v", err) + } +} + +func TestUserService_GetByID_NotFound(t *testing.T) { + svc := newUserService() + ctx := context.Background() + + _, err := svc.GetByID(ctx, "nonexistent") + if !errors.Is(err, ErrNotFound) { + t.Fatalf("expected ErrNotFound, got %v", err) + } +} diff --git a/internal/service/validate.go b/internal/service/validate.go new file mode 100644 index 00000000..854c09d9 --- /dev/null +++ b/internal/service/validate.go @@ -0,0 +1,48 @@ +package service + +import ( + "regexp" + "strings" + "unicode/utf8" +) + +var usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`) + +func validatePassword(s string) bool { + n := utf8.RuneCountInString(s) + return n >= 12 && n <= 128 +} + +// validateUsername проверяет формат username по README: строго [a-z0-9_]{3,32}. +func validateUsername(s string) bool { + return usernameRe.MatchString(s) +} + +// validateDisplayName проверяет display_name: 1–100 Unicode code points, +// не состоит только из пробельных символов. +func validateDisplayName(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 100 +} + +// validateTitle проверяет title чата: 1–100 code points, не только пробелы. +func validateTitle(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 100 +} + +// validateText проверяет text сообщения: 1–4000 code points, не только пробелы. +// В lab4 появится возможность отправить пустой text, если есть attachment_ids. +func validateText(s string) bool { + if strings.TrimSpace(s) == "" { + return false + } + n := utf8.RuneCountInString(s) + return n >= 1 && n <= 4000 +} diff --git a/internal/transport/http/auth.go b/internal/transport/http/auth.go new file mode 100644 index 00000000..104b7903 --- /dev/null +++ b/internal/transport/http/auth.go @@ -0,0 +1,92 @@ +package http + +import ( + "encoding/base64" + "net/http" + "strings" + "time" + + "github.com/charawein/mtusi2026lab2/internal/domain" + "github.com/charawein/mtusi2026lab2/internal/service" + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +type AuthHandler struct { + auth *service.AuthService +} + +func NewAuthHandler(auth *service.AuthService) *AuthHandler { + return &AuthHandler{auth: auth} +} + +type sessionResponse struct { + Token string `json:"token"` + TokenType string `json:"token_type"` + ExpiresAt string `json:"expires_at"` + User *domain.User `json:"user"` +} + +func (h *AuthHandler) CreateSession(w http.ResponseWriter, r *http.Request) { + username, password, ok := parseBasicAuth(r.Header.Get("Authorization")) + if !ok { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + sess, u, err := h.auth.Login(r.Context(), username, password) + if err != nil { + if err == service.ErrUnauthorized { + w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`) + } + httputil.WriteError(w, r, err) + return + } + + // Формат RFC3339 без микросекунд: "2026-10-09T19:00:36Z". + // Python-клиент тестов ожидает 'Z' в конце строки. + httputil.WriteJSON(w, r, http.StatusCreated, sessionResponse{ + Token: sess.Token, + TokenType: "Bearer", + ExpiresAt: sess.ExpiresAt.UTC().Truncate(time.Second).Format(time.RFC3339), + User: u, + }) +} + +func (h *AuthHandler) RevokeSession(w http.ResponseWriter, r *http.Request) { + token := bearerToken(r) + if token == "" { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + if err := h.auth.Logout(r.Context(), token); err != nil { + httputil.WriteError(w, r, err) + return + } + w.WriteHeader(http.StatusNoContent) +} + +func parseBasicAuth(h string) (string, string, bool) { + const prefix = "Basic " + if !strings.HasPrefix(h, prefix) { + return "", "", false + } + raw, err := base64.StdEncoding.DecodeString(h[len(prefix):]) + if err != nil { + return "", "", false + } + parts := strings.SplitN(string(raw), ":", 2) + if len(parts) != 2 { + return "", "", false + } + return parts[0], parts[1], true +} + +func bearerToken(r *http.Request) string { + h := r.Header.Get("Authorization") + if !strings.HasPrefix(h, "Bearer ") { + return "" + } + return strings.TrimPrefix(h, "Bearer ") +} diff --git a/internal/transport/http/chat.go b/internal/transport/http/chat.go new file mode 100644 index 00000000..d67dcc26 --- /dev/null +++ b/internal/transport/http/chat.go @@ -0,0 +1,86 @@ +package http + +import ( + "log/slog" + "net/http" + + "github.com/charawein/mtusi2026lab2/internal/service" + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +type ChatHandler struct { + chats *service.ChatService +} + +func NewChatHandler(chats *service.ChatService) *ChatHandler { + return &ChatHandler{chats: chats} +} + +func (h *ChatHandler) CreateChat(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + var body struct { + Title string `json:"title"` + MemberIDs []string `json:"member_ids"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + c, err := h.chats.Create(r.Context(), uid, body.Title, body.MemberIDs) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, c) +} + +func (h *ChatHandler) ListChats(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + limit, err := httputil.ParseLimit(r) + if err != nil { + httputil.WriteError(w, r, err) + return + } + cursor := r.URL.Query().Get("cursor") + + items, next, err := h.chats.List(r.Context(), uid, cursor, limit) + if err != nil { + // ВРЕМЕННО: логируем точную ошибку + slog.Error("ListChats failed", "err", err, "uid", uid, "cursor", cursor, "limit", limit) + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, httputil.PageResponse{Items: items, NextCursor: httputil.NextOrNull(next)}) +} + +func (h *ChatHandler) GetChat(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + c, err := h.chats.Get(r.Context(), uid, chatID) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, c) +} diff --git a/internal/transport/http/health.go b/internal/transport/http/health.go new file mode 100644 index 00000000..38cc19a4 --- /dev/null +++ b/internal/transport/http/health.go @@ -0,0 +1,25 @@ +package http + +import ( + "net/http" + + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +type HealthHandler struct{} + +func NewHealthHandler() *HealthHandler { + return &HealthHandler{} +} + +func (h *HealthHandler) Live(w http.ResponseWriter, r *http.Request) { + httputil.WriteJSON(w, r, http.StatusOK, healthResponse{Status: "ok"}) +} + +func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) { + httputil.WriteJSON(w, r, http.StatusOK, healthResponse{Status: "ok"}) +} + +type healthResponse struct { + Status string `json:"status"` +} diff --git a/internal/transport/http/message.go b/internal/transport/http/message.go new file mode 100644 index 00000000..e86b1872 --- /dev/null +++ b/internal/transport/http/message.go @@ -0,0 +1,73 @@ +package http + +import ( + "net/http" + + "github.com/charawein/mtusi2026lab2/internal/service" + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +type MessageHandler struct { + messages *service.MessageService +} + +func NewMessageHandler(messages *service.MessageService) *MessageHandler { + return &MessageHandler{messages: messages} +} + +func (h *MessageHandler) SendMessage(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + var body struct { + Text string `json:"text"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + m, err := h.messages.Send(r.Context(), uid, chatID, body.Text) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, m) +} + +func (h *MessageHandler) ListMessages(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + + chatID := r.PathValue("chat_id") + if chatID == "" { + httputil.WriteError(w, r, service.ErrInvalidInput) + return + } + + limit, err := httputil.ParseLimit(r) + if err != nil { + httputil.WriteError(w, r, err) + return + } + cursor := r.URL.Query().Get("cursor") + + items, next, err := h.messages.List(r.Context(), uid, chatID, cursor, limit) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, httputil.PageResponse{Items: items, NextCursor: httputil.NextOrNull(next)}) +} diff --git a/internal/transport/http/middleware/auth.go b/internal/transport/http/middleware/auth.go new file mode 100644 index 00000000..52326c7e --- /dev/null +++ b/internal/transport/http/middleware/auth.go @@ -0,0 +1,48 @@ +package middleware + +import ( + "errors" + "log/slog" + "net/http" + "strings" + + "github.com/charawein/mtusi2026lab2/internal/service" + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +// Auth проверяет Authorization: Bearer через AuthService. +func Auth(auth *service.AuthService) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + header := r.Header.Get("Authorization") + if !strings.HasPrefix(header, "Bearer ") { + writeUnauthorized(w, r) + return + } + token := strings.TrimPrefix(header, "Bearer ") + if token == "" { + writeUnauthorized(w, r) + return + } + + u, err := auth.ValidateSession(r.Context(), token) + if err != nil { + if errors.Is(err, service.ErrUnauthorized) { + writeUnauthorized(w, r) + return + } + slog.Error("auth: unexpected", "err", err) + httputil.WriteError(w, r, nil) + return + } + + ctx := httputil.ContextWithUserID(r.Context(), u.ID) + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} + +func writeUnauthorized(w http.ResponseWriter, r *http.Request) { + w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`) + httputil.WriteError(w, r, service.ErrUnauthorized) +} diff --git a/internal/transport/http/middleware/logging.go b/internal/transport/http/middleware/logging.go new file mode 100644 index 00000000..744550e3 --- /dev/null +++ b/internal/transport/http/middleware/logging.go @@ -0,0 +1,34 @@ +package middleware + +import ( + "log/slog" + "net/http" + "time" + + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +type statusRecorder struct { + http.ResponseWriter + status int +} + +func (r *statusRecorder) WriteHeader(code int) { + r.status = code + r.ResponseWriter.WriteHeader(code) +} + +func Logging(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + start := time.Now() + rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK} + next.ServeHTTP(rec, r) + slog.Info("http request", + "request_id", httputil.RequestIDFrom(r.Context()), + "method", r.Method, + "path", r.URL.Path, + "status", rec.status, + "duration_ms", time.Since(start).Milliseconds(), + ) + }) +} diff --git a/internal/transport/http/middleware/recovery.go b/internal/transport/http/middleware/recovery.go new file mode 100644 index 00000000..b489daa8 --- /dev/null +++ b/internal/transport/http/middleware/recovery.go @@ -0,0 +1,25 @@ +package middleware + +import ( + "log/slog" + "net/http" + + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +func Recovery(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + defer func() { + if rec := recover(); rec != nil { + slog.Error("panic in handler", + "panic", rec, + "request_id", httputil.RequestIDFrom(r.Context()), + "method", r.Method, + "path", r.URL.Path, + ) + httputil.WriteError(w, r, nil) + } + }() + next.ServeHTTP(w, r) + }) +} diff --git a/internal/transport/http/middleware/request_id.go b/internal/transport/http/middleware/request_id.go new file mode 100644 index 00000000..9481b9ee --- /dev/null +++ b/internal/transport/http/middleware/request_id.go @@ -0,0 +1,29 @@ +package middleware + +import ( + "crypto/rand" + "fmt" + "net/http" + + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +func RequestID(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + id := r.Header.Get("X-Request-Id") + if id == "" { + id = newRequestID() + } + w.Header().Set("X-Request-Id", id) + ctx := httputil.ContextWithRequestID(r.Context(), id) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func newRequestID() string { + var b [12]byte + if _, err := rand.Read(b[:]); err != nil { + panic(fmt.Sprintf("crypto/rand failed: %v", err)) + } + return fmt.Sprintf("%x", b[:]) +} diff --git a/internal/transport/http/router.go b/internal/transport/http/router.go new file mode 100644 index 00000000..7f4bc08c --- /dev/null +++ b/internal/transport/http/router.go @@ -0,0 +1,53 @@ +package http + +import ( + "net/http" + + "github.com/charawein/mtusi2026lab2/internal/service" + "github.com/charawein/mtusi2026lab2/internal/transport/http/middleware" +) + +func NewRouter( + users *service.UserService, + chats *service.ChatService, + messages *service.MessageService, + auth *service.AuthService, +) http.Handler { + userH := NewUserHandler(users) + chatH := NewChatHandler(chats) + msgH := NewMessageHandler(messages) + authH := NewAuthHandler(auth) + healthH := NewHealthHandler() + + mux := http.NewServeMux() + + mux.HandleFunc("GET /health/live", healthH.Live) + mux.HandleFunc("GET /health/ready", healthH.Ready) + mux.HandleFunc("POST /api/v1/users", userH.CreateUser) + mux.HandleFunc("POST /api/v1/auth/sessions", authH.CreateSession) + + // Debug endpoints для демонстрации трека 5.1 (не входят в публичный контракт). + mux.HandleFunc("POST /debug/cache/on", func(w http.ResponseWriter, r *http.Request) { + messages.SetInvalidate(true) + w.WriteHeader(http.StatusNoContent) + }) + mux.HandleFunc("POST /debug/cache/off", func(w http.ResponseWriter, r *http.Request) { + messages.SetInvalidate(false) + w.WriteHeader(http.StatusNoContent) + }) + + authMW := middleware.Auth(auth) + + mux.Handle("DELETE /api/v1/auth/sessions/current", authMW(http.HandlerFunc(authH.RevokeSession))) + mux.Handle("GET /api/v1/users/me", authMW(http.HandlerFunc(userH.CurrentUser))) + mux.Handle("POST /api/v1/chats", authMW(http.HandlerFunc(chatH.CreateChat))) + mux.Handle("GET /api/v1/chats", authMW(http.HandlerFunc(chatH.ListChats))) + mux.Handle("GET /api/v1/chats/{chat_id}", authMW(http.HandlerFunc(chatH.GetChat))) + mux.Handle("POST /api/v1/chats/{chat_id}/messages", authMW(http.HandlerFunc(msgH.SendMessage))) + mux.Handle("GET /api/v1/chats/{chat_id}/messages", authMW(http.HandlerFunc(msgH.ListMessages))) + + handler := middleware.Logging(mux) + handler = middleware.Recovery(handler) + handler = middleware.RequestID(handler) + return handler +} diff --git a/internal/transport/http/user.go b/internal/transport/http/user.go new file mode 100644 index 00000000..8029a854 --- /dev/null +++ b/internal/transport/http/user.go @@ -0,0 +1,49 @@ +package http + +import ( + "net/http" + + "github.com/charawein/mtusi2026lab2/internal/service" + "github.com/charawein/mtusi2026lab2/internal/transport/httputil" +) + +type UserHandler struct { + users *service.UserService +} + +func NewUserHandler(users *service.UserService) *UserHandler { + return &UserHandler{users: users} +} + +func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) { + var body struct { + Username string `json:"username"` + DisplayName string `json:"display_name"` + Password string `json:"password"` + } + if err := httputil.DecodeJSON(r, &body); err != nil { + httputil.WriteError(w, r, err) + return + } + + u, err := h.users.Register(r.Context(), body.Username, body.DisplayName, body.Password) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusCreated, u) +} + +func (h *UserHandler) CurrentUser(w http.ResponseWriter, r *http.Request) { + uid := httputil.UserIDFromContext(r.Context()) + if uid == "" { + httputil.WriteError(w, r, service.ErrUnauthorized) + return + } + u, err := h.users.GetByID(r.Context(), uid) + if err != nil { + httputil.WriteError(w, r, err) + return + } + httputil.WriteJSON(w, r, http.StatusOK, u) +} diff --git a/internal/transport/httputil/response.go b/internal/transport/httputil/response.go new file mode 100644 index 00000000..0d21c253 --- /dev/null +++ b/internal/transport/httputil/response.go @@ -0,0 +1,154 @@ +package httputil + +import ( + "context" + "encoding/json" + "errors" + "log/slog" + "net/http" + "strconv" + + "github.com/charawein/mtusi2026lab2/internal/service" +) + +// requestIDKey — ключ контекста для X-Request-Id. +type requestIDKey struct{} + +// ContextWithRequestID кладёт request_id в контекст. Используется middleware.RequestID. +func ContextWithRequestID(ctx context.Context, id string) context.Context { + return context.WithValue(ctx, requestIDKey{}, id) +} + +// RequestIDFrom извлекает request_id из контекста. +func RequestIDFrom(ctx context.Context) string { + if v, ok := ctx.Value(requestIDKey{}).(string); ok { + return v + } + return "" +} + +// userIDKey — ключ контекста для аутентифицированного user_id. +type userIDKey struct{} + +// ContextWithUserID кладёт user_id в контекст. Используется middleware.Auth. +func ContextWithUserID(ctx context.Context, id string) context.Context { + return context.WithValue(ctx, userIDKey{}, id) +} + +// UserIDFromContext извлекает user_id из контекста. +func UserIDFromContext(ctx context.Context) string { + if v, ok := ctx.Value(userIDKey{}).(string); ok { + return v + } + return "" +} + +// errorBody — формат тела ошибки по contracts/openapi.json. +type errorBody struct { + Error errorDetail `json:"error"` +} + +type errorDetail struct { + Code string `json:"code"` + Message string `json:"message"` + RequestID string `json:"request_id"` +} + +// WriteJSON пишет JSON-ответ с заданным статусом. +func WriteJSON(w http.ResponseWriter, r *http.Request, status int, v any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + if v == nil { + return + } + if err := json.NewEncoder(w).Encode(v); err != nil { + slog.Error("failed to encode response", "err", err, "request_id", RequestIDFrom(r.Context())) + } +} + +// WriteError мапит доменную ошибку в HTTP-статус и пишет тело в формате контракта. +func WriteError(w http.ResponseWriter, r *http.Request, err error) { + status, code := mapError(err) + reqID := RequestIDFrom(r.Context()) + if reqID == "" { + reqID = "missing-request-id" + } + body := errorBody{Error: errorDetail{ + Code: code, + Message: messageFor(code), + RequestID: reqID, + }} + WriteJSON(w, r, status, body) +} + +func mapError(err error) (int, string) { + switch { + case errors.Is(err, service.ErrInvalidInput): + return http.StatusBadRequest, "invalid_request" + case errors.Is(err, service.ErrUnauthorized): + return http.StatusUnauthorized, "unauthorized" + case errors.Is(err, service.ErrNotFound): + return http.StatusNotFound, "not_found" + case errors.Is(err, service.ErrConflict): + return http.StatusConflict, "conflict" + default: + return http.StatusInternalServerError, "internal_error" + } +} + +func messageFor(code string) string { + switch code { + case "invalid_request": + return "Неверный запрос" + case "unauthorized": + return "Требуется аутентификация" + case "not_found": + return "Объект не найден" + case "conflict": + return "Конфликт" + case "internal_error": + return "Внутренняя ошибка" + default: + return "Ошибка" + } +} + +// DecodeJSON парсит тело запроса в v, строго запрещая неизвестные поля. +func DecodeJSON(r *http.Request, v any) error { + dec := json.NewDecoder(r.Body) + dec.DisallowUnknownFields() + if err := dec.Decode(v); err != nil { + return service.ErrInvalidInput + } + if dec.More() { + return service.ErrInvalidInput + } + return nil +} + +// ParseLimit читает query-параметр limit с дефолтом и границами по контракту. +func ParseLimit(r *http.Request) (int, error) { + s := r.URL.Query().Get("limit") + if s == "" { + return 50, nil + } + n, err := strconv.Atoi(s) + if err != nil || n < 1 || n > 100 { + return 0, service.ErrInvalidInput + } + return n, nil +} + +// PageResponse — универсальный ответ пагинации. +type PageResponse struct { + Items any `json:"items"` + NextCursor *string `json:"next_cursor"` +} + +// NextOrNull превращает пустую строку в nil (для сериализации в null). +func NextOrNull(s string) *string { + if s == "" { + return nil + } + return &s +} diff --git a/migrations/0001_init.down.sql b/migrations/0001_init.down.sql new file mode 100644 index 00000000..99dada2b --- /dev/null +++ b/migrations/0001_init.down.sql @@ -0,0 +1,6 @@ +-- Откат миграции 0001 +DROP TABLE IF EXISTS sessions; +DROP TABLE IF EXISTS messages; +DROP TABLE IF EXISTS chat_members; +DROP TABLE IF EXISTS chats; +DROP TABLE IF EXISTS users; \ No newline at end of file diff --git a/migrations/0001_init.up.sql b/migrations/0001_init.up.sql new file mode 100644 index 00000000..9875ce62 --- /dev/null +++ b/migrations/0001_init.up.sql @@ -0,0 +1,50 @@ +-- migrations/0001_init.sql + +-- Пользователи +CREATE TABLE 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 DEFAULT now() +); + +-- Чаты +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Членство +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_idx ON chat_members(user_id); + +-- Сообщения +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Главный индекс для пагинации +CREATE INDEX messages_chat_created_id_idx + ON messages (chat_id, created_at, id); + +-- Сессии (если SESSION_STORE=postgres) +CREATE TABLE sessions ( + token TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE INDEX sessions_expires_idx ON sessions(expires_at); +CREATE INDEX sessions_user_idx ON sessions(user_id); \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..29c0e90c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +# Перезапускает API и все используемые хранилища с сохранением volumes. +# Не удаляет данные, не пересоздаёт схему, не сеет данные повторно. +docker compose --env-file .env restart api postgres redis \ No newline at end of file diff --git a/scripts/seed10k.sh b/scripts/seed10k.sh new file mode 100644 index 00000000..4398e1f3 --- /dev/null +++ b/scripts/seed10k.sh @@ -0,0 +1,24 @@ +#!/bin/bash +set -eu +BASE=http://localhost:8080 +USER=$(curl -s -X POST $BASE/api/v1/users -H "Content-Type: application/json" \ + -d '{"username":"explainuser","display_name":"Explain","password":"Example-only-not-a-real-secret-123"}') +USER_ID=$(echo $USER | python3 -c "import sys,json; print(json.load(sys.stdin)['id'])") +CRED=$(printf "explainuser:Example-only-not-a-real-secret-123" | base64 -w0) +SESSION=$(curl -s -X POST $BASE/api/v1/auth/sessions -H "Authorization: Basic $CRED") +TOKEN=$(echo $SESSION | python3 -c "import sys,json; print(json.load(sys.stdin)['token'])") +CHAT=$(curl -s -X POST $BASE/api/v1/chats -H "Content-Type: application/json" \ + -H "Authorization: Bearer $TOKEN" \ + -d "{\"title\":\"Explain\",\"member_ids\":[\"$USER_ID\"]}") +CHAT_ID=$(echo $CHAT | python3 -c "import sys,json; print(json.load(sys.stdin)['id'])") +echo "USER_ID=$USER_ID" +echo "CHAT_ID=$CHAT_ID" +for i in $(seq 1 10000); do + curl -s -X POST "$BASE/api/v1/chats/$CHAT_ID/messages" \ + -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \ + -d "{\"text\":\"msg $i\"}" > /dev/null + if [ $((i % 1000)) -eq 0 ]; then echo "Sent $i"; fi +done +echo "DONE" +echo "CHAT_ID=$CHAT_ID" +echo "TOKEN=$TOKEN" \ No newline at end of file diff --git a/scripts/stale_read_demo.sh b/scripts/stale_read_demo.sh new file mode 100644 index 00000000..da51af33 --- /dev/null +++ b/scripts/stale_read_demo.sh @@ -0,0 +1,61 @@ +#!/bin/bash +set -eu + +BASE=http://localhost:8080 +CHAT_ID=aa29af3d-b946-4358-b7e6-eb6aedaf1ee0 + +# 1. СНАЧАЛА чистим Redis (до логина!) +docker compose exec redis redis-cli FLUSHALL > /dev/null +echo "Redis flushed" + +# 2. Теперь логинимся — сессия создаётся и живёт +CRED=$(printf "explainuser:Example-only-not-a-real-secret-123" | base64 -w0) +TOKEN=$(curl -s -X POST "$BASE/api/v1/auth/sessions" -H "Authorization: Basic $CRED" \ + | python3 -c "import sys,json; sys.stdout.write(json.load(sys.stdin)['token'])") +echo "TOKEN=[$TOKEN]" + +# 3. Проверка, что токен работает +CODE=$(curl -s -o /dev/null -w "%{http_code}" "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN") +echo "/messages status: $CODE" +if [ "$CODE" != "200" ]; then + echo "STOP: /messages returned $CODE" + exit 1 +fi + +# === BUG MODE === +curl -s -X POST "$BASE/debug/cache/off" > /dev/null +echo "=== BUG MODE (invalidation OFF) ===" + +curl -s "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN" > /tmp/read1.json +echo "Read1 items: $(python3 -c 'import json; print(len(json.load(open("/tmp/read1.json"))["items"]))')" + +echo "Redis cache keys:" +docker compose exec redis redis-cli KEYS 'messages:*' + +curl -s -X POST "$BASE/api/v1/chats/$CHAT_ID/messages" \ + -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \ + -d '{"text":"STALE_MARKER_XYZ"}' > /dev/null + +DB=$(docker compose exec -T postgres psql -U messenger -d messenger -t -A \ + -c "SELECT COUNT(*) FROM messages WHERE text='STALE_MARKER_XYZ';") +echo "DB STALE_MARKER_XYZ: $DB" + +curl -s "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN" > /tmp/read2.json +echo "Read2 STALE count: $(grep -c STALE_MARKER_XYZ /tmp/read2.json)" + +# === FIXED MODE === +curl -s -X POST "$BASE/debug/cache/on" > /dev/null +echo "=== FIXED MODE (invalidation ON) ===" + +curl -s -X POST "$BASE/api/v1/chats/$CHAT_ID/messages" \ + -H "Content-Type: application/json" -H "Authorization: Bearer $TOKEN" \ + -d '{"text":"FIXED_MARKER_ABC"}' > /dev/null + +curl -s "$BASE/api/v1/chats/$CHAT_ID/messages?limit=50" -H "Authorization: Bearer $TOKEN" > /tmp/read3.json +echo "Read3 FIXED count: $(grep -c FIXED_MARKER_ABC /tmp/read3.json)" + +echo "" +echo "=== SUMMARY ===" +echo "DB STALE: $DB" +echo "Read2 (bug): $(grep -c STALE_MARKER_XYZ /tmp/read2.json)" +echo "Read3 (fixed): $(grep -c FIXED_MARKER_ABC /tmp/read3.json)" \ No newline at end of file