lab2: postgres, sessions, redis, persistence, stale read
Skeleton contracts / contracts (pull_request) Canceled after 0s
Skeleton contracts / contracts (pull_request) Canceled after 0s
This commit is contained in:
+54
@@ -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"]
|
||||
@@ -1,37 +1,216 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Вейнмайер Андрей Андреевич, БВТ2303
|
||||
- Целевая оценка: 5 (уровни 3, 4, трек 5.1)
|
||||
- Commit/PR: <URL MR>
|
||||
- Использованные источники:
|
||||
- Контракт: 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.
|
||||
+100
@@ -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")
|
||||
}
|
||||
@@ -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:
|
||||
Binary file not shown.
@@ -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
|
||||
Binary file not shown.
@@ -0,0 +1,2 @@
|
||||
1) "session:-p3QE-W4uB-mVaLw_tFMhcm3K65RufBAE59ZVi6TABQ"
|
||||
2) "session:dqpgjo2m7OZVryghhb331A6vzLbZhByHxZkELcItUpg"
|
||||
@@ -0,0 +1,3 @@
|
||||
aof_enabled:1
|
||||
aof_last_bgrewrite_status:ok
|
||||
aof_last_write_status:ok
|
||||
@@ -0,0 +1 @@
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -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.
|
||||
@@ -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
|
||||
)
|
||||
@@ -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=
|
||||
@@ -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
|
||||
}
|
||||
@@ -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),
|
||||
})
|
||||
}
|
||||
@@ -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),
|
||||
})
|
||||
}
|
||||
@@ -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:"-"`
|
||||
}
|
||||
@@ -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),
|
||||
})
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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")
|
||||
)
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
@@ -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$<salt>$<hash>.
|
||||
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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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 ")
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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"`
|
||||
}
|
||||
@@ -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)})
|
||||
}
|
||||
@@ -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 <token> через 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)
|
||||
}
|
||||
@@ -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(),
|
||||
)
|
||||
})
|
||||
}
|
||||
@@ -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)
|
||||
})
|
||||
}
|
||||
@@ -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[:])
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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;
|
||||
@@ -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);
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Перезапускает API и все используемые хранилища с сохранением volumes.
|
||||
# Не удаляет данные, не пересоздаёт схему, не сеет данные повторно.
|
||||
docker compose --env-file .env restart api postgres redis
|
||||
@@ -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"
|
||||
@@ -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)"
|
||||
Reference in New Issue
Block a user