Author SHA1 Message Date
wanderinho bdccb3ad7d ЛР3 - БПИ2303 - Стругов - на 4 2026-11-10 15:19:31 +03:00
33 changed files with 3591 additions and 23 deletions
+21
View File
@@ -0,0 +1,21 @@
FROM golang:1.22.5-alpine AS build
WORKDIR /src
COPY src/go.mod src/go.sum ./
RUN go mod download
COPY src/ ./
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger .
FROM scratch
USER 10001:10001
COPY --from=build /out/messenger /app/messenger
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \
CMD ["/app/messenger", "-healthcheck"]
ENTRYPOINT ["/app/messenger"]
+93 -23
View File
@@ -1,37 +1,107 @@
# Отчёт — лабораторная 3
# Отчёт — лабораторная работа № 3 (целевая оценка: 4)
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
**Автор:** Стругов Максим
**Группа:** БПИ2303
**Целевая оценка:** 4
## Запуск из чистого clone
## 1. Воспроизводимый запуск
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требования: Docker Engine и Docker Compose plugin; Go на хосте не требуется; Python 3.9+ для проверочных скриптов.
## Архитектура и решения
```sh
cp .env.example .env
./scripts/init-secrets.sh
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --scale api=2 --wait
make check
make validate
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
./scripts/restore.sh
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
После восстановления реплик проверить `docker compose ps api`: должны работать два экземпляра API со статусом `healthy`.
## Доказательства критериев
Публично опубликован только адрес `127.0.0.1:8080` балансировщика Nginx. API, PostgreSQL и Redis доступны внутри сети Docker Compose, но не публикуют свои порты на хост. Данные PostgreSQL сохраняются в Docker volume. Команда `docker compose down` останавливает стек без удаления данных; `docker compose down -v` **удаляет тома и учебные данные**, поэтому используется только осознанно.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
Секреты создаются локально, не должны попадать в Git. Для `secrets/database_url.txt` и `secrets/cache_url.txt` установлены права `640`, группа `10001` — GID процесса API. После изменения прав контейнер API был перезапущен и успешно достиг состояния `healthy`.
## 2. Архитектура и технические решения
**Схема:** клиент → Nginx 1.27.5 → две реплики Go API → общие PostgreSQL 16.4 и Redis 7.4.
- **Реплики API.** Приложение не хранит критическое состояние в локальной памяти контейнера. Обе реплики работают с общими PostgreSQL и Redis. Заголовок `X-Instance-Id` содержит идентификатор экземпляра и позволяет проверить распределение запросов.
- **Сессии.** PostgreSQL — источник истины для пользователей, чатов, сообщений и сессий. Решение о действительности Bearer-токена принимается по PostgreSQL; положительный ответ Redis-кэша не используется как самостоятельное подтверждение доступа. Это предотвращает доверие устаревшей записи после отзыва токена на другой реплике.
- **Идемпотентность.** Для создания сообщений используется `Idempotency-Key`; в PostgreSQL действует уникальность `(user_id, chat_id, key)`. Запись сообщения и ключа идемпотентности выполняется транзакционно. В рамках лабораторной тело запроса канонизируется как текст и пустой список вложений.
- **Балансировщик.** Nginx использует Docker DNS `127.0.0.11` и динамическое разрешение `api:8080` (`resolve`, `valid=2s`). Настроены `proxy_connect_timeout 1s`, `proxy_read_timeout 12s`, `proxy_send_timeout 12s` и максимум две upstream-попытки при предусмотренных сетевых ошибках. Автоматический повтор уже отправленного POST не гарантируется: повтор небезопасен без учёта идемпотентности.
- **Healthcheck и остановка.** Проверка здоровья контейнера выполняется каждые 5 секунд. Go HTTP-сервер использует graceful shutdown с тайм-аутом 8 секунд; Compose задаёт `stop_grace_period: 10s`.
- **Миграции.** Отдельный одноразовый сервис `migrate` запускает `golang-migrate` до старта API. SQL-миграции встроены в Go-бинарь через `go:embed`; применённые версии учитываются в `schema_migrations`.
**Особенность настройки Nginx по результатам эксперимента:** в upstream добавлено `server api:8080 resolve max_fails=0;`. Параметр отключает пассивное исключение адреса после неудачных попыток соединения. Это помогло в повторном испытании, но означает, что Nginx может продолжать выбирать недоступный IP до обновления Docker DNS. Активных health probes upstream в данной конфигурации нет.
## 3. Проверки и доказательства
| Критерий | Команда / сценарий | Фактический результат | Доказательство |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Структура репозитория | `make check` | `PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.` | Вывод терминала; при сдаче сохранить в `evidence/` |
| OpenAPI 3.1 и JSON Schema | `make validate` | `PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.` | Вывод терминала |
| Публичный API | `make test` | `PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.` | Вывод терминала |
| Персистентность | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.` | Вывод терминала и `scripts/restart.sh` |
| Отказ одной реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 115 успешных записей, 0 неудачных попыток, первая успешная запись после воздействия через 0,474 с; тест завершился `PASS` | Вывод JSON и `scripts/stop-one.sh` |
| Балансировка | 20 последовательных запросов `/health/live` | В ответах наблюдались два разных `X-Instance-Id`, соответствующие двум репликам | Вывод `curl` |
| Конкурентная идемпотентность | `python3 tests/idempotency_concurrent.py` | 20 параллельных запросов с одинаковым ключом, один уникальный ID сообщения, ответы от двух реплик; `PASS` | Вывод теста; файл скрипта |
| Обычная нагрузка до обновления | `python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load.json` | 11 816 успешных запросов, 0 ошибок; 393,589 успешных запросов/с; p50 7,992 мс, p95 27,642 мс, p99 46,719 мс | `evidence/load.json` |
| Замена под нагрузкой | `scripts/rolling-update.sh` одновременно с `tests/load.py` | **35 685 успешных POST, 0 ошибок; обе реплики заменены и стали `healthy`** | `evidence/rolling-load.json`, `evidence/rolling-update.log` |
| Версия миграций | `SELECT version, dirty FROM schema_migrations;` | `version=2`, `dirty=false` | Вывод `psql` |
| Доступ к секретам | `chmod 640`, `ls -l`, перезапуск одной реплики | Группа файлов `10001`, режим `640`; перезапущенная `api-6` стала `healthy`, `api-7` оставалась `healthy` | Вывод `ls`, `docker inspect`, `docker compose ps api` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### 3.1. Проверка отказа одной реплики
## Эксперименты и отказы
Тест `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` завершился успешно: 115 записей, 0 неудачных попыток, первая успешная запись после воздействия через 0,474 секунды. Дополнительно вручную остановлена одна реплика, а запрос к `/health/live` через Nginx продолжил возвращать HTTP 200 от второй. После запуска остановленной реплики и перехода в `healthy` Nginx снова распределял запросы между двумя `X-Instance-Id`.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Указанное время 0,474 секунды — метрика конкретного теста, а не гарантия максимального времени восстановления при любых условиях.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
### 3.2. Поочерёдная замена реплик под нагрузкой
## Ограничения и следующие шаги
Использован сценарий **эквивалентной поочерёдной замены контейнеров** Docker Compose, а не обновление образа на новую версию приложения. Скрипт запоминает ID двух исходных контейнеров, удаляет их по одному, вызывает `docker compose up -d --no-deps --no-recreate --scale api=2 api` и ожидает `healthy` новой реплики перед переходом к следующей. Флаг `--no-recreate` сохраняет работающий второй экземпляр. Compose может выдавать новым контейнерам следующие порядковые номера (`api-4`, `api-5` и т. д.), поэтому алгоритм не привязан к именам `api-1` и `api-2`.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Условия нагрузочного испытания: 90 секунд, конкурентность 4, закрытая модель нагрузки (closed-loop), создание сообщений через POST, без автоматических повторов на стороне нагрузочного клиента.
| Метрика | Первый прогон | Повторный прогон после изменения Nginx |
| --- | ---: | ---: |
| Длительность | 90,018 с | 90,021 с |
| Успешные запросы | 34 594 | **35 685** |
| Неуспешные запросы | **5 661** | **0** |
| Доля ошибок | 14,0628% | **0%** |
| Успешных запросов/с | 384,301 | 396,409 |
| p50 успешных запросов | 8,035 мс | 8,014 мс |
| p95 успешных запросов | 25,285 мс | 25,782 мс |
| p99 успешных запросов | 39,950 мс | 39,431 мс |
| Замена двух реплик | PASS | PASS |
**Разбор неудачного прогона.** В логах Nginx многократно появлялось `no live upstreams while connecting to upstream` для POST-запросов. Это показывает, что балансировщик в некоторые моменты не имел доступного upstream. После изменения upstream на `server api:8080 resolve max_fails=0;` повторный прогон завершился без зарегистрированных ошибок. Эксперимент подтверждает улучшение в измеренных условиях
**Ограничение методики.** Перцентили вычисляются только по успешным запросам; ошибочные запросы учитываются отдельно. Closed-loop-нагрузка подвержена coordinated omission и накладным расходам клиента. Был проведён один повторный успешный прогон, а не три независимых повтора; поэтому статистическая воспроизводимость результата не установлена. Интервалы недоступности по секундам и CPU/RAM не замерялись.
### 3.3. Миграции и совместимость схемы
Сервис `migrate` выполняется как отдельная одноразовая задача, от успешного завершения которой зависит запуск API. Это отделяет изменение схемы от старта каждой реплики. `golang-migrate` отслеживает версии и состояние миграций; запрос к `schema_migrations` показал `version=2`, `dirty=false`.
`0001_init` создаёт основные таблицы и индексы. `0002_idempotency` добавляет таблицу `message_idempotency` с уникальным составным ключом и индексом срока хранения, не удаляя существующие поля или таблицы. Это **добавочное изменение схемы**, потенциально совместимое с работающей предыдущей версией приложения. Однако совместная работа старой версии API с новой схемой **не проверялась экспериментально**, поэтому полной гарантии обратной совместимости нет. Для будущих несовместимых изменений требуется поэтапный подход expand–migrate–contract.
Наличие `version=2, dirty=false` подтверждает завершённое состояние схемы, но само по себе не доказывает количество фактических запусков контейнера миграций. Одноразовость обеспечивается архитектурой Compose (`migrate` как отдельный job), а не приведённым SQL-запросом.
## 4. Ограничения и риски
1. **SPOF.** Один Nginx, один PostgreSQL и один Docker-хост остаются едиными точками отказа; отказ хоста или PostgreSQL не переживается автоматически.
2. **DNS и upstream.** При смене контейнеров возможны краткие ошибки до обновления DNS. `max_fails=0` отключает пассивное исключение неработающего адреса и имеет собственный компромисс: такой адрес может выбираться повторно.
3. **Границы rolling update.** Подтверждена последовательная замена контейнеров на текущем образе. Развёртывание новой версии образа и проверка совместимости двух разных версий приложения не проводились.
4. **Идемпотентность.** Ключи сохраняются на 24 часа и далее: автоматическая очистка истёкших записей пока отсутствует. Это не приводит к повторной записи при сохранённом ключе, но требует обслуживания таблицы и уточнения политики повторного использования ключей.
5. **Redis.** Redis не является источником истины для авторизации. Проверка PostgreSQL на каждом запросе упрощает корректность отзыва сессий, но добавляет нагрузку на БД и ограничивает масштабирование.
6. **Методика нагрузки.** Отсутствуют три независимых повтора успешного прогона, замеры CPU/RAM и точная временная диаграмма ошибок. Не следует утверждать, что система гарантирует zero downtime при любой нагрузке.
7. **Старые данные.** При использовании базы с несовместимым форматом служебной таблицы миграций может потребоваться отдельная процедура переноса; `docker compose down -v` удаляет данные и не является безопасным способом обновления рабочей БД.
## 5. Источники, инструменты и использование ИИ
Исходные требования и контракт курса: `contracts/openapi.json`, `contracts/README.md`, `contracts/infrastructure.json`. В проекте используются Go, `pgx/v5`, `golang-migrate/v4`, `go-redis/v9`, PostgreSQL, Redis, Nginx и Docker Compose. Для анализа реализации, диагностики ошибок Nginx, подготовки сценариев испытаний и оформления отчёта использовался ChatGPT. Команды и фактические результаты экспериментов проверялись на Docker-хосте автором работы. Данные измерений не подменялись оценками ИИ.
+70
View File
@@ -0,0 +1,70 @@
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets: [postgres_password]
volumes: [pgdata:/var/lib/postgresql/data]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 3s
timeout: 2s
retries: 20
mem_limit: 512m
cpus: 1.0
restart: unless-stopped
redis:
image: redis:7.4.1-alpine
command: ["redis-server", "--save", "", "--appendonly", "no"]
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 3s
timeout: 2s
retries: 20
mem_limit: 128m
cpus: 0.5
restart: unless-stopped
migrate:
build: {context: ., dockerfile: Dockerfile}
entrypoint: ["/app/messenger", "-migrate"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets: [database_url]
depends_on:
postgres: {condition: service_healthy}
restart: "no"
api:
build: {context: ., dockerfile: Dockerfile}
environment:
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: docker
SESSION_TTL_SECONDS: "3600"
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
secrets: [database_url, cache_url]
depends_on:
migrate: {condition: service_completed_successfully}
redis: {condition: service_healthy}
mem_limit: 256m
cpus: 0.75
stop_grace_period: 10s
restart: unless-stopped
lb:
image: nginx:1.27.5-alpine
volumes:
- ./infra/nginx.conf:/etc/nginx/nginx.conf:ro
ports: ["127.0.0.1:8080:8080"]
depends_on:
api: {condition: service_healthy}
mem_limit: 128m
cpus: 0.5
restart: unless-stopped
secrets:
postgres_password: {file: ./secrets/postgres_password.txt}
database_url: {file: ./secrets/database_url.txt}
cache_url: {file: ./secrets/cache_url.txt}
volumes:
pgdata:
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 3,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.021,
"concurrency": 4,
"successful_requests": 11816,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 393.589,
"successful_latency_ms": {
"p50": 7.992,
"p95": 27.642,
"p99": 46.719
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+2
View File
@@ -0,0 +1,2 @@
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
+2
View File
@@ -0,0 +1,2 @@
python3 scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
+5
View File
@@ -0,0 +1,5 @@
version | dirty
---------+-------
2 | f
(1 row)
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 3,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 90.0,
"elapsed_seconds": 90.021,
"concurrency": 4,
"successful_requests": 35685,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 396.409,
"successful_latency_ms": {
"p50": 8.014,
"p95": 25.782,
"p99": 39.431
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+4
View File
@@ -0,0 +1,4 @@
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 106, "failed_attempts": 1, "first_recovery_seconds": 1.517}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
+3
View File
@@ -0,0 +1,3 @@
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+26
View File
@@ -0,0 +1,26 @@
events { worker_connections 1024; }
http {
access_log /dev/stdout;
error_log /dev/stderr warn;
resolver 127.0.0.11 valid=2s ipv6=off;
upstream api_backends {
zone api_backends 64k;
server api:8080 resolve max_fails=0;
keepalive 16;
}
server {
listen 8080;
location / {
proxy_pass http://api_backends;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_connect_timeout 1s;
proxy_read_timeout 12s;
proxy_send_timeout 12s;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
# POST is not transparently retried: client uses Idempotency-Key.
}
}
}
+10
View File
@@ -0,0 +1,10 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
mkdir -p secrets
if [ -e secrets/postgres_password.txt ]; then echo 'Secrets already exist; leaving unchanged'; exit 0; fi
password=$(od -An -N24 -tx1 /dev/urandom | tr -d ' \n')
printf '%s' "$password" > secrets/postgres_password.txt
printf 'postgres://messenger:%s@postgres:5432/messenger?sslmode=disable' "$password" > secrets/database_url.txt
printf '%s' 'redis://redis:6379/0' > secrets/cache_url.txt
chmod 600 secrets/*.txt
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose down
docker compose up -d --scale api=2 --build --wait
+8
View File
@@ -0,0 +1,8 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose up -d --scale api=2 --no-recreate api
# Explicitly start any stopped API container (Compose does not necessarily do so).
for id in $(docker compose ps -a -q api); do
if [ "$(docker inspect --format '{{.State.Running}}' "$id")" = false ]; then docker start "$id" >/dev/null; fi
done
+71
View File
@@ -0,0 +1,71 @@
#!/usr/bin/env bash
set -euo pipefail
cd "$(dirname "$0")/.."
# Запоминаем именно исходные контейнеры.
mapfile -t old_ids < <(docker compose ps -q api)
if [[ "${#old_ids[@]}" -ne 2 ]]; then
echo "ERROR: expected exactly two API replicas"
exit 1
fi
wait_healthy() {
local id="$1"
local deadline=$((SECONDS + 60))
local status=""
while (( SECONDS < deadline )); do
status=$(docker inspect \
-f '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' \
"$id" 2>/dev/null || true)
if [[ "$status" == "healthy" ]]; then
return 0
fi
sleep 1
done
echo "ERROR: container $id did not become healthy"
return 1
}
for old_id in "${old_ids[@]}"; do
echo "Replacing $old_id..."
docker stop --timeout 10 "$old_id"
docker rm "$old_id"
docker compose up -d \
--no-deps \
--no-recreate \
--scale api=2 \
api
mapfile -t current_ids < <(docker compose ps -q api)
if [[ "${#current_ids[@]}" -ne 2 ]]; then
echo "ERROR: expected two API replicas after replacement"
exit 1
fi
new_id=""
for id in "${current_ids[@]}"; do
if [[ "$id" != "${old_ids[0]}" && "$id" != "${old_ids[1]}" ]]; then
new_id="$id"
fi
done
if [[ -z "$new_id" ]]; then
echo "ERROR: new API replica not found"
exit 1
fi
wait_healthy "$new_id"
echo "New replica $new_id is healthy"
done
echo "PASS: sequential API replica replacement completed"
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?test provides instance alias}"
# Default Docker hostname is the container's short ID, used as X-Instance-Id.
for id in $(docker compose ps -q api); do
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$id")
if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then
docker stop --time 2 "$id" >/dev/null
exit 0
fi
done
printf '%s\n' 'No running API container matches TARGET_INSTANCE_ID' >&2
exit 1
+1127
View File
File diff suppressed because it is too large Load Diff
+103
View File
@@ -0,0 +1,103 @@
package main
import (
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strings"
"unicode/utf8"
"golang.org/x/crypto/argon2"
)
// --- пароли: Argon2id -------------------------------------------------------
//
// Выбран Argon2id, а не bcrypt: bcrypt молча обрезает пароль до 72 байт,
// а у нас пароль — 12..128 Unicode code points без ограничения по алфавиту
// (кириллица/эмодзи — 2-4 байта на символ), так что 128 code points легко
// превышают 72 байта и bcrypt тихо обрежет "хвост" пароля без ошибки.
// Argon2id не имеет такого ограничения и к тому же обязателен для lab7 —
// так что это не временное решение, а сразу целевая схема.
const (
argonTime = 3
argonMemory = 64 * 1024 // 64 MiB
argonThreads = 2
argonKeyLen = 32
argonSaltLen = 16
)
var errPasswordHashFormat = errors.New("неизвестный формат хэша пароля")
// validPassword: 12..128 Unicode code points, не только пробелы.
// Валидность UTF-8 самого запроса уже проверена в decodeJSON до этого места.
func validPassword(s string) bool {
n := utf8.RuneCountInString(s)
return n >= 12 && n <= 128 && strings.TrimSpace(s) != ""
}
// hashPassword возвращает самоописывающуюся строку: parameters+salt+hash,
// поэтому параметры можно менять в будущем без миграции данных (старые
// хэши остаются проверяемыми со своими же параметрами).
func hashPassword(password string) (string, error) {
salt := make([]byte, argonSaltLen)
if _, err := rand.Read(salt); err != nil {
return "", fmt.Errorf("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 пересчитывает хэш с параметрами и солью ИЗ сохранённой
// строки (а не текущими константами) — старые хэши продолжают проверяться
// даже если argonTime/argonMemory поменяются в новой версии бинаря.
func verifyPassword(encoded, password string) (bool, error) {
parts := strings.Split(encoded, "$")
if len(parts) != 6 || parts[1] != "argon2id" {
return false, errPasswordHashFormat
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil {
return false, errPasswordHashFormat
}
var memory, time uint32
var threads uint8
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &time, &threads); err != nil {
return false, errPasswordHashFormat
}
salt, err := base64.RawStdEncoding.DecodeString(parts[4])
if err != nil {
return false, errPasswordHashFormat
}
want, err := base64.RawStdEncoding.DecodeString(parts[5])
if err != nil {
return false, errPasswordHashFormat
}
got := argon2.IDKey([]byte(password), salt, time, memory, threads, uint32(len(want)))
return subtle.ConstantTimeCompare(got, want) == 1, nil
}
// --- сессии: непрозрачный opaque bearer-токен -------------------------------
// newSessionToken: 32 случайных байта (256 бит энтропии) в base64url без
// паддинга — непрозрачное значение, не username/UUID/JWT.
func newSessionToken() (string, error) {
b := make([]byte, 32)
if _, err := rand.Read(b); err != nil {
return "", err
}
return base64.RawURLEncoding.EncodeToString(b), nil
}
// hashToken: в БД/кэше хранится не сам токен, а его SHA-256 — утечка
// таблицы сессий/дампа Redis не отдаёт действующие bearer-токены напрямую.
func hashToken(token string) []byte {
sum := sha256.Sum256([]byte(token))
return sum[:]
}
+154
View File
@@ -0,0 +1,154 @@
package main
import (
"context"
"encoding/json"
"log/slog"
"time"
"github.com/redis/go-redis/v9"
)
// sessionCache — необязательный read-through кэш валидных сессий перед
// Postgres. Источник истины всегда Postgres (таблица sessions); Redis
// только ускоряет самый горячий путь — проверку Bearer-токена на КАЖДОМ
// защищённом запросе. Если sessionCache == nil (CACHE_URL не задан —
// уровень 3), store всегда идёт прямо в Postgres: корректность не зависит
// от наличия кэша, только скорость.
type sessionCache struct {
rdb *redis.Client
}
// cachedSession хранит весь User, а не только user_id: при попадании в кэш
// это полностью избавляет от похода в Postgres (включая JOIN на users),
// а не просто от одной проверки токена — это и есть выигрыш от кэша на
// самом горячем пути (Bearer-проверка есть на каждом защищённом запросе).
type cachedSession struct {
UserID string `json:"user_id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt string `json:"created_at"`
ExpiresAt time.Time `json:"expires_at"`
// Revoked — надгробие, которое ставит logout, если DEL не удался:
// запись нельзя использовать как подтверждение сессии.
Revoked bool `json:"revoked,omitempty"`
}
// cacheMaxTTL ограничивает срок жизни записи независимо от срока сессии:
// даже в худшем случае (отказ и DEL, и SET при logout, другая реплика) кэш
// не может дольше этого окна отдавать уже отозванный токен как валидный.
const cacheMaxTTL = time.Minute
func newSessionCache(addr string) (*sessionCache, error) {
opt, err := redis.ParseURL(addr)
if err != nil {
return nil, err
}
rdb := redis.NewClient(opt)
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
if err := rdb.Ping(ctx).Err(); err != nil {
rdb.Close()
return nil, err
}
return &sessionCache{rdb: rdb}, nil
}
func (c *sessionCache) Close() error {
if c == nil {
return nil
}
return c.rdb.Close()
}
func cacheKey(tokenHash []byte) string {
return "sess:" + string(tokenHash)
}
// get: кэш-промах (ключа нет) и ошибка связи с Redis возвращают одно и то
// же — (nil, false) без error — вызывающий код просто идёт в Postgres.
// Это и есть "корректно обходит кэш при недоступности": отказ Redis никогда
// не трактуется как "сессия валидна" и никогда не роняет запрос — он
// просто чуть медленнее идёт в основной источник истины.
func (c *sessionCache) get(ctx context.Context, tokenHash []byte) (*cachedSession, bool) {
if c == nil {
return nil, false
}
data, err := c.rdb.Get(ctx, cacheKey(tokenHash)).Bytes()
if err != nil {
if err != redis.Nil {
slog.Warn("redis get недоступен, идём в Postgres", "err", err)
}
return nil, false
}
var s cachedSession
if err := json.Unmarshal(data, &s); err != nil {
return nil, false
}
return &s, true
}
// set пишет запись с TTL = min(ОСТАВШИЙСЯ срок сессии, cacheMaxTTL) — кэш
// не может продлить сессию дольше, чем она реально действует в Postgres.
func (c *sessionCache) set(ctx context.Context, tokenHash []byte, u User, expiresAt time.Time) {
if c == nil {
return
}
ttl := time.Until(expiresAt)
if ttl <= 0 {
return
}
if ttl > cacheMaxTTL {
ttl = cacheMaxTTL
}
data, err := json.Marshal(cachedSession{
UserID: u.ID,
Username: u.Username,
DisplayName: u.DisplayName,
CreatedAt: u.CreatedAt,
ExpiresAt: expiresAt,
})
if err != nil {
return
}
if err := c.rdb.Set(ctx, cacheKey(tokenHash), data, ttl).Err(); err != nil {
slog.Warn("redis set недоступен, кэш не обновлён", "err", err)
}
}
// invalidate — инвалидация записи при logout (Postgres к этому моменту уже
// отмечен revoked). Возвращает true, только если кэш гарантированно больше
// не отдаст токен как «валидный»:
// 1. DEL ключа; если DEL не прошёл (ошибка связи, ACL запрещает DEL...) —
// 2. запись-надгробие (revoked=true) поверх ключа обычным SET: чтение
// видит надгробие и идёт в Postgres, а не доверяет кэшу.
//
// Если не прошло и это — false: вызывающий код обязан закрыть токен иначе
// (локальный deny-list в Store), а не молча оставить кэш «валидным».
func (c *sessionCache) invalidate(ctx context.Context, tokenHash []byte, ttl time.Duration) bool {
if c == nil {
return true
}
key := cacheKey(tokenHash)
err := c.rdb.Del(ctx, key).Err()
if err == nil {
return true
}
slog.Warn("redis del не прошёл при logout, ставим надгробие", "err", err)
if ttl <= 0 {
ttl = time.Minute
}
data, _ := json.Marshal(cachedSession{Revoked: true})
if err := c.rdb.Set(ctx, key, data, ttl).Err(); err != nil {
slog.Error("redis: не удалось ни удалить, ни пометить запись отозванной", "err", err)
return false
}
return true
}
func (c *sessionCache) Ping(ctx context.Context) error {
if c == nil {
return nil
}
return c.rdb.Ping(ctx).Err()
}
+45
View File
@@ -0,0 +1,45 @@
package main
import (
"context"
"fmt"
"time"
"github.com/jackc/pgx/v5/pgxpool"
)
// openPool открывает pgx-пул соединений с ограничениями: без лимита один
// зависший клиент/медленный запрос мог бы захватить все соединения Postgres.
// pgxpool — "родной" пул для pgx (в отличие от generic database/sql),
// с нативной поддержкой PostgreSQL-типов и собственным health-check'ом фона.
func openPool(ctx context.Context, dsn string) (*pgxpool.Pool, error) {
cfg, err := pgxpool.ParseConfig(dsn)
if err != nil {
return nil, fmt.Errorf("парсинг DSN: %w", err)
}
cfg.MaxConns = 20
cfg.MinConns = 1
cfg.MaxConnLifetime = 30 * time.Minute
cfg.MaxConnIdleTime = 5 * time.Minute
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, fmt.Errorf("создание пула: %w", err)
}
pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, fmt.Errorf("ping: %w", err)
}
return pool, nil
}
// queryTimeout — таймаут на отдельный SQL-запрос: зависший диск/сеть к БД
// не должен вешать HTTP-обработчик навечно.
const queryTimeout = 3 * time.Second
func withTimeout(parent context.Context) (context.Context, context.CancelFunc) {
return context.WithTimeout(parent, queryTimeout)
}
+25
View File
@@ -0,0 +1,25 @@
module messenger
go 1.22.0
require (
github.com/golang-migrate/migrate/v4 v4.18.1
github.com/jackc/pgx/v5 v5.7.1
github.com/redis/go-redis/v9 v9.7.0
golang.org/x/crypto v0.31.0
)
require (
github.com/cespare/xxhash/v2 v2.2.0 // indirect
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
github.com/hashicorp/errwrap v1.1.0 // indirect
github.com/hashicorp/go-multierror v1.1.1 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
github.com/lib/pq v1.12.3 // indirect; indirect (используется внутри golang-migrate/database/postgres, не нашим кодом)
go.uber.org/atomic v1.7.0 // indirect
golang.org/x/sync v0.10.0 // indirect
golang.org/x/sys v0.28.0 // indirect
golang.org/x/text v0.21.0 // indirect
)
+93
View File
@@ -0,0 +1,93 @@
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
github.com/dhui/dktest v0.4.3 h1:wquqUxAFdcUgabAVLvSCOKOlag5cIZuaOjYIBOWdsR0=
github.com/dhui/dktest v0.4.3/go.mod h1:zNK8IwktWzQRm6I/l2Wjp7MakiyaFWv4G1hjmodmMTs=
github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
github.com/docker/docker v27.2.0+incompatible h1:Rk9nIVdfH3+Vz4cyI/uhbINhEZ/oLmc+CBXmH6fbNk4=
github.com/docker/docker v27.2.0+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/golang-migrate/migrate/v4 v4.18.1 h1:JML/k+t4tpHCpQTCAD62Nu43NUFzHY4CV3uAuvHGC+Y=
github.com/golang-migrate/migrate/v4 v4.18.1/go.mod h1:HAX6m3sQgcdO81tdjn5exv20+3Kb13cmGli1hrD6hks=
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.7.1 h1:x7SYsPBYDkHDksogeSmZZ5xzThcTgRz++I5E+ePFUcs=
github.com/jackc/pgx/v5 v5.7.1/go.mod h1:e7O26IywZZ+naJtWWos6i6fvWK+29etgITqrqHLfoZA=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ=
github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA=
github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E=
github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 h1:TT4fX+nBOA/+LUkobKGW1ydGcn+G3vRw9+g5HwCphpk=
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8=
go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw=
go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8=
go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc=
go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8=
go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4=
go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ=
go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+430
View File
@@ -0,0 +1,430 @@
package main
import (
"context"
"errors"
"io"
"net"
"net/http"
"regexp"
"strconv"
"strings"
"sync/atomic"
"github.com/jackc/pgx/v5/pgconn"
)
type api struct {
store *Store
draining *atomic.Bool
}
var idempotencyKeyRE = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
// isUnavailable: ошибка означает «зависимость недоступна» (обрыв/отказ
// соединения, таймаут, остановка сервера PostgreSQL), а не логическую
// ошибку запроса или баг. Такие ошибки отдаются как 503, не 404/500.
func isUnavailable(err error) bool {
if err == nil {
return false
}
if errors.Is(err, context.DeadlineExceeded) ||
errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
return true
}
var netErr net.Error
if errors.As(err, &netErr) {
return true
}
var connErr *pgconn.ConnectError
if errors.As(err, &connErr) {
return true
}
if pgconn.SafeToRetry(err) || pgconn.Timeout(err) {
return true
}
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) {
// 08 — connection exception, 57P — admin shutdown/crash/cannot connect now,
// 53 — нехватка ресурсов сервера.
c := pgErr.Code
return strings.HasPrefix(c, "08") || strings.HasPrefix(c, "57P") || strings.HasPrefix(c, "53")
}
msg := err.Error()
return strings.Contains(msg, "conn closed") || strings.Contains(msg, "closed pool")
}
// writeStoreError превращает неожиданную ошибку хранилища в ответ:
// недоступность БД -> 503 unavailable, всё прочее -> 500.
func writeStoreError(w http.ResponseWriter, err error) {
if isUnavailable(err) {
writeError(w, http.StatusServiceUnavailable, "unavailable", "Хранилище недоступно")
return
}
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
}
func (a *api) routes() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /health/live", a.live)
mux.HandleFunc("GET /health/ready", a.ready)
mux.HandleFunc("POST /api/v1/users", a.registerUser)
mux.HandleFunc("GET /api/v1/users/me", a.currentUser)
mux.HandleFunc("POST /api/v1/auth/sessions", a.createSession)
mux.HandleFunc("DELETE /api/v1/auth/sessions/current", a.revokeSession)
mux.HandleFunc("POST /api/v1/chats", a.createChat)
mux.HandleFunc("GET /api/v1/chats", a.listChats)
mux.HandleFunc("GET /api/v1/chats/{chat_id}", a.getChat)
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", a.createMessage)
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", a.listMessages)
// Всё остальное — JSON-ошибка в общем формате.
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
writeError(w, http.StatusNotFound, "not_found", "Ресурс не найден")
})
return withMiddleware(mux)
}
// bearerToken достаёт токен из "Authorization: Bearer <token>".
// Пустой/неверный формат/другая схема (например Basic на бизнес-endpoint) — "", false.
func bearerToken(r *http.Request) (string, bool) {
h := r.Header.Get("Authorization")
const prefix = "Bearer "
if len(h) <= len(prefix) || !strings.EqualFold(h[:len(prefix)], prefix) {
return "", false
}
token := strings.TrimSpace(h[len(prefix):])
if token == "" {
return "", false
}
return token, true
}
// auth — lab2+: защищённые endpoint принимают только Authorization: Bearer
// <token> действующей сессии. X-User-Id с lab2 игнорируется полностью: сам
// по себе он больше не даёт доступа ни к чему.
func (a *api) auth(w http.ResponseWriter, r *http.Request) (User, bool) {
token, ok := bearerToken(r)
if !ok {
unauthorized(w, "Bearer", "Требуется действительный Bearer-токен")
return User{}, false
}
u, valid, err := a.store.ValidateSession(r.Context(), token)
if err != nil {
writeError(w, http.StatusServiceUnavailable, "unavailable", "Хранилище сессий недоступно")
return User{}, false
}
if !valid {
unauthorized(w, "Bearer", "Сессия недействительна, истекла или отозвана")
return User{}, false
}
return u, true
}
// chatID: неверный UUID в пути — 400 (проверяется после аутентификации).
func chatID(w http.ResponseWriter, r *http.Request) (string, bool) {
id := r.PathValue("chat_id")
if !uuidRe.MatchString(id) {
badRequest(w, "Некорректный chat_id")
return "", false
}
return strings.ToLower(id), true
}
// pageParams разбирает limit и cursor. scope привязывает курсор к ресурсу.
func pageParams(w http.ResponseWriter, r *http.Request, scope string) (limit int, after *pos, ok bool) {
q := r.URL.Query()
limit = 50
if q.Has("limit") {
n, err := strconv.Atoi(q.Get("limit"))
if err != nil || n < 1 || n > 100 {
badRequest(w, "limit должен быть целым числом от 1 до 100")
return 0, nil, false
}
limit = n
}
if q.Has("cursor") {
p, valid := decodeCursor(scope, q.Get("cursor"))
if !valid {
badRequest(w, "Некорректный cursor")
return 0, nil, false
}
after = p
}
return limit, after, true
}
func (a *api) live(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
// ready: единственная критичная зависимость обязательного синхронного
// пути — PostgreSQL. Redis недоступен -> деградация скорости, не отказ.
func (a *api) ready(w http.ResponseWriter, r *http.Request) {
if a.draining != nil && a.draining.Load() {
writeError(w, 503, "unavailable", "API завершает работу")
return
}
if err := a.store.Ready(r.Context()); err != nil {
writeError(w, http.StatusServiceUnavailable, "unavailable", "PostgreSQL недоступен")
return
}
writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
}
func (a *api) registerUser(w http.ResponseWriter, r *http.Request) {
var req struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
if !decodeJSON(w, r, &req) {
return
}
if !usernameRe.MatchString(req.Username) || !validText(req.DisplayName, 100) || !validPassword(req.Password) {
badRequest(w, "Некорректные username, display_name или password")
return
}
hash, err := hashPassword(req.Password)
if err != nil {
writeStoreError(w, err)
return
}
u, err := a.store.CreateUser(r.Context(), req.Username, req.DisplayName, hash)
if errors.Is(err, errConflict) {
writeError(w, http.StatusConflict, "conflict", "Username уже занят")
return
}
if err != nil {
writeStoreError(w, err)
return
}
writeJSON(w, http.StatusCreated, u)
}
func (a *api) currentUser(w http.ResponseWriter, r *http.Request) {
if u, ok := a.auth(w, r); ok {
writeJSON(w, http.StatusOK, u)
}
}
// createSession — вход: Authorization: Basic username:password, без JSON body.
func (a *api) createSession(w http.ResponseWriter, r *http.Request) {
username, password, ok := r.BasicAuth()
if !ok {
unauthorized(w, "Basic", "Требуется Authorization: Basic username:password")
return
}
u, err := a.store.AuthenticateUser(r.Context(), username, password)
if errors.Is(err, errUnauthorized) {
unauthorized(w, "Basic", "Неверный username или password")
return
}
if err != nil {
writeStoreError(w, err)
return
}
session, err := a.store.CreateSession(r.Context(), u)
if err != nil {
writeStoreError(w, err)
return
}
writeJSON(w, http.StatusCreated, session)
}
// revokeSession — logout: отзывает текущий Bearer-токен, 204 без тела.
func (a *api) revokeSession(w http.ResponseWriter, r *http.Request) {
_, ok := a.auth(w, r)
if !ok {
return
}
token, _ := bearerToken(r) // уже проверен в auth()
if err := a.store.RevokeSession(r.Context(), token); err != nil {
writeStoreError(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (a *api) createChat(w http.ResponseWriter, r *http.Request) {
me, ok := a.auth(w, r)
if !ok {
return
}
var req struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
if !decodeJSON(w, r, &req) {
return
}
if !validText(req.Title, 100) || len(req.MemberIDs) < 1 || len(req.MemberIDs) > 100 {
badRequest(w, "Некорректные title или member_ids")
return
}
seen := make(map[string]bool, len(req.MemberIDs))
members := make([]string, 0, len(req.MemberIDs))
for _, raw := range req.MemberIDs {
if !uuidRe.MatchString(raw) {
badRequest(w, "Некорректный UUID в member_ids")
return
}
id := strings.ToLower(raw)
if seen[id] {
badRequest(w, "Дубликаты в member_ids")
return
}
seen[id] = true
members = append(members, id)
}
if !seen[me.ID] {
badRequest(w, "member_ids должен включать вызывающего")
return
}
c, err := a.store.CreateChat(r.Context(), req.Title, members)
if errors.Is(err, errInvalid) {
badRequest(w, "Неизвестный участник в member_ids")
return
}
if err != nil {
writeStoreError(w, err)
return
}
writeJSON(w, http.StatusCreated, c)
}
func (a *api) listChats(w http.ResponseWriter, r *http.Request) {
me, ok := a.auth(w, r)
if !ok {
return
}
limit, after, ok := pageParams(w, r, "c:"+me.ID)
if !ok {
return
}
items, more, err := a.store.ListChats(r.Context(), me.ID, after, limit)
if err != nil {
writeStoreError(w, err)
return
}
var next *string
if more {
last := items[len(items)-1]
s := encodeCursor("c:"+me.ID, last.CreatedAt, last.ID)
next = &s
}
writeJSON(w, http.StatusOK, map[string]any{"items": items, "next_cursor": next})
}
func (a *api) getChat(w http.ResponseWriter, r *http.Request) {
me, ok := a.auth(w, r)
if !ok {
return
}
id, ok := chatID(w, r)
if !ok {
return
}
c, err := a.store.GetChat(r.Context(), me.ID, id)
if errors.Is(err, errNotFound) {
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
return
}
if err != nil {
writeStoreError(w, err)
return
}
writeJSON(w, http.StatusOK, c)
}
func (a *api) createMessage(w http.ResponseWriter, r *http.Request) {
me, ok := a.auth(w, r)
if !ok {
return
}
id, ok := chatID(w, r)
if !ok {
return
}
// Порядок из контракта: аутентификация -> доступ к ресурсу -> валидация тела.
if _, err := a.store.GetChat(r.Context(), me.ID, id); err != nil {
if errors.Is(err, errNotFound) {
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
} else {
writeStoreError(w, err) // отказ БД — 503/500, а не «чата нет»
}
return
}
key := r.Header.Get("Idempotency-Key")
if !idempotencyKeyRE.MatchString(key) {
badRequest(w, "Требуется корректный Idempotency-Key")
return
}
var req struct {
Text string `json:"text"`
AttachmentIDs []string `json:"attachment_ids"`
}
if !decodeJSON(w, r, &req) {
return
}
if len(req.AttachmentIDs) > 0 {
badRequest(w, "Вложения доступны с лабораторной 4")
return
}
if !validText(req.Text, 4000) {
badRequest(w, "text должен содержать от 1 до 4000 символов и не состоять из пробелов")
return
}
m, err := a.store.AddMessageIdempotent(r.Context(), me.ID, id, key, req.Text)
if errors.Is(err, errNotFound) {
writeError(w, 404, "not_found", "Чат не найден")
return
}
if errors.Is(err, errConflict) {
writeError(w, 409, "conflict", "Ключ уже использован с другим содержимым")
return
}
if err != nil {
writeStoreError(w, err)
return
}
writeJSON(w, http.StatusCreated, m)
}
func (a *api) listMessages(w http.ResponseWriter, r *http.Request) {
me, ok := a.auth(w, r)
if !ok {
return
}
id, ok := chatID(w, r)
if !ok {
return
}
if _, err := a.store.GetChat(r.Context(), me.ID, id); err != nil {
if errors.Is(err, errNotFound) {
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
} else {
writeStoreError(w, err) // отказ БД — 503/500, а не «чата нет»
}
return
}
limit, after, ok := pageParams(w, r, "m:"+id)
if !ok {
return
}
items, more, err := a.store.ListMessages(r.Context(), me.ID, id, after, limit)
if errors.Is(err, errNotFound) {
writeError(w, http.StatusNotFound, "not_found", "Чат не найден")
return
}
if err != nil {
writeStoreError(w, err)
return
}
var next *string
if more {
last := items[len(items)-1]
s := encodeCursor("m:"+id, last.CreatedAt, last.ID)
next = &s
}
writeJSON(w, http.StatusOK, map[string]any{"items": items, "next_cursor": next})
}
+232
View File
@@ -0,0 +1,232 @@
package main
import (
"bytes"
"crypto/rand"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"mime"
"net/http"
"os"
"reflect"
"regexp"
"runtime/debug"
"strings"
"time"
"unicode/utf8"
)
var instanceID = func() string {
if v := env("INSTANCE_ID", ""); v != "" {
return v
}
if h, e := os.Hostname(); e == nil {
return h
}
return newUUID()
}()
var (
usernameRe = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
uuidRe = regexp.MustCompile(`^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`)
)
const maxBodyBytes = 1 << 20 // 1 MiB — с запасом для любого JSON lab1
func newUUID() string {
var b [16]byte
if _, err := rand.Read(b[:]); err != nil {
panic(err)
}
b[6] = (b[6] & 0x0f) | 0x40 // version 4
b[8] = (b[8] & 0x3f) | 0x80 // variant
return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
}
// validText: длина в Unicode code points (не байтах) и не только пробелы.
func validText(s string, maxRunes int) bool {
n := utf8.RuneCountInString(s)
return n >= 1 && n <= maxRunes && strings.TrimSpace(s) != ""
}
// --- ответы ----------------------------------------------------------------
func writeJSON(w http.ResponseWriter, status int, v any) {
var buf bytes.Buffer
enc := json.NewEncoder(&buf)
enc.SetEscapeHTML(false)
if err := enc.Encode(v); err != nil {
writeError(w, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
w.Write(buf.Bytes())
}
type errBody struct {
Error struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
} `json:"error"`
}
// writeError берёт request_id из заголовка, который выставил middleware,
// поэтому тело и заголовок гарантированно совпадают.
func writeError(w http.ResponseWriter, status int, code, message string) {
var b errBody
b.Error.Code = code
b.Error.Message = message
b.Error.RequestID = w.Header().Get("X-Request-Id")
writeJSON(w, status, b)
}
func badRequest(w http.ResponseWriter, msg string) {
writeError(w, http.StatusBadRequest, "invalid_request", msg)
}
// unauthorized: WWW-Authenticate обязан соответствовать схеме, ожидаемой
// именно на этом endpoint — Basic на /auth/sessions, Bearer на всех
// остальных защищённых endpoint (так требует contracts/README.md и это
// же проверяет client.py).
func unauthorized(w http.ResponseWriter, scheme, msg string) {
switch scheme {
case "Basic":
w.Header().Set("WWW-Authenticate", `Basic realm="messenger", charset="UTF-8"`)
case "Bearer":
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
}
writeError(w, http.StatusUnauthorized, "unauthorized", msg)
}
// decodeJSON: 415 для чужого Content-Type, 413 для огромного тела,
// 400 для битого JSON / неверных типов / лишних полей / мусора после объекта /
// ключей, отличающихся от поля только регистром / невалидного UTF-8 в строках.
func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
mt, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil || mt != "application/json" {
writeError(w, http.StatusUnsupportedMediaType, "unsupported_media_type", "Ожидается application/json")
return false
}
r.Body = http.MaxBytesReader(w, r.Body, maxBodyBytes)
body, err := io.ReadAll(r.Body)
if err != nil {
var tooBig *http.MaxBytesError
if errors.As(err, &tooBig) {
writeError(w, http.StatusRequestEntityTooLarge, "payload_too_large", "Тело запроса слишком большое")
} else {
badRequest(w, "Некорректный JSON")
}
return false
}
// encoding/json не проверяет валидность UTF-8 при декодировании: битый
// байт внутри строки тихо заменяется на U+FFFD (валидный код-пойнт) ещё
// на этапе unquote, до того как значение попадёт в Go-строку. Поэтому
// проверять decoded-строку уже поздно — надежда только на сырые байты
// тела до разбора JSON.
if !utf8.Valid(body) {
badRequest(w, "Тело запроса содержит невалидный UTF-8")
return false
}
dec := json.NewDecoder(bytes.NewReader(body))
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
var tooBig *http.MaxBytesError
if errors.As(err, &tooBig) {
writeError(w, http.StatusRequestEntityTooLarge, "payload_too_large", "Тело запроса слишком большое")
} else {
badRequest(w, "Некорректный JSON")
}
return false
}
if _, err := dec.Token(); err != io.EOF {
badRequest(w, "Некорректный JSON")
return false
}
// encoding/json сопоставляет JSON-ключ с полем struct без учёта регистра
// при точном совпадении имени нет приоритета у DisallowUnknownFields —
// он проверяет только "это вообще известное поле", а не "написано так же".
// Поэтому {"TEXT": "..."} при наличии json:"text" проходит как известное
// поле и тихо перезаписывает значение. Отдельно сверяем точное написание.
if !checkExactFieldCase(w, body, dst) {
return false
}
return true
}
// checkExactFieldCase отклоняет тело, где JSON-ключ совпадает с именем поля
// struct (по его json-тегу) без учёта регистра, но не совпадает побуквенно —
// иначе такой ключ проходит DisallowUnknownFields как "известный" и тихо
// перезаписывает значение правильно написанного поля.
func checkExactFieldCase(w http.ResponseWriter, body []byte, dst any) bool {
var raw map[string]json.RawMessage
if err := json.Unmarshal(body, &raw); err != nil {
// Не JSON-объект на верхнем уровне — обычный decode уже либо
// отработал на примитиве, либо провалился раньше.
return true
}
t := reflect.TypeOf(dst)
for t.Kind() == reflect.Ptr {
t = t.Elem()
}
if t.Kind() != reflect.Struct {
return true
}
// lower(json-тег) -> точное написание тега
known := make(map[string]string, t.NumField())
for i := 0; i < t.NumField(); i++ {
name := strings.Split(t.Field(i).Tag.Get("json"), ",")[0]
if name == "" || name == "-" {
continue
}
known[strings.ToLower(name)] = name
}
for key := range raw {
if exact, ok := known[strings.ToLower(key)]; ok && key != exact {
badRequest(w, "Поле \""+key+"\" отличается от \""+exact+"\" только регистром")
return false
}
}
return true
}
// --- middleware ------------------------------------------------------------
type statusRecorder struct {
http.ResponseWriter
status int
}
func (s *statusRecorder) WriteHeader(code int) {
s.status = code
s.ResponseWriter.WriteHeader(code)
}
// withMiddleware: request id -> access log -> recover -> handler.
// В логах только метод, путь (без query), статус и время: тексты сообщений не попадают.
func withMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
rid := newUUID()
w.Header().Set("X-Request-Id", rid)
w.Header().Set("X-Instance-Id", instanceID)
rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
start := time.Now()
defer func() {
if p := recover(); p != nil {
slog.Error("panic", "request_id", rid, "panic", fmt.Sprint(p), "stack", string(debug.Stack()))
writeError(rec, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка")
}
slog.Info("request", "request_id", rid, "method", r.Method, "path", r.URL.Path,
"status", rec.status, "duration_ms", time.Since(start).Milliseconds())
}()
next.ServeHTTP(rec, r)
})
}
+157
View File
@@ -0,0 +1,157 @@
package main
import (
"context"
"flag"
"log/slog"
"net"
"net/http"
"os"
"os/signal"
"strconv"
"strings"
"sync/atomic"
"syscall"
"time"
)
func env(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
// secret читает значение либо из файла, на который указывает <KEY>_FILE
// (Docker secrets — так рекомендует .env.example), либо из обычной
// переменной <KEY>, либо берёт def. Секреты никогда не передаются в
// командной строке/аргументах процесса — только файл или переменная
// окружения самого контейнера.
func secret(key, def string) string {
if path := os.Getenv(key + "_FILE"); path != "" {
data, err := os.ReadFile(path)
if err != nil {
slog.Error("не удалось прочитать secret-файл", "env", key+"_FILE", "path", path, "err", err)
os.Exit(1)
}
return strings.TrimSpace(string(data))
}
return env(key, def)
}
// probe нужен для Docker HEALTHCHECK в минимальном образе, где нет curl/wget:
//
// HEALTHCHECK CMD ["/app/messenger", "-healthcheck"]
func probe(port string) int {
c := http.Client{Timeout: 2 * time.Second}
resp, err := c.Get("http://" + net.JoinHostPort("127.0.0.1", port) + "/health/ready")
if err != nil {
return 1
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return 1
}
return 0
}
func main() {
migrate := flag.Bool("migrate", false, "применить миграции и завершиться")
healthcheck := flag.Bool("healthcheck", false, "проверить /health/ready и выйти с кодом 0/1")
flag.Parse()
host := env("APP_HOST", "0.0.0.0")
port := env("APP_PORT", "8080")
if *healthcheck {
os.Exit(probe(port))
}
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
// Дефолт — только для локального запуска без Docker secrets; в compose
// значение приходит из DATABASE_URL_FILE (см. .env.example/compose.yaml).
dsn := secret("DATABASE_URL", "postgres://messenger:messenger@localhost:5432/messenger?sslmode=disable")
if *migrate {
if err := runMigrations(dsn); err != nil {
slog.Error("migrations failed", "err", err)
os.Exit(1)
}
return
}
// Миграции выполняет только отдельный one-shot сервис migrate.
// Для локальной отладки: messenger -migrate.
ctx0, cancel0 := context.WithTimeout(context.Background(), 10*time.Second)
db, err := openPool(ctx0, dsn)
cancel0()
if err != nil {
slog.Error("не удалось подключиться к PostgreSQL", "err", err)
os.Exit(1)
}
defer db.Close()
// CACHE_URL не задан => работаем без Redis (level 3: только Postgres,
// корректность не зависит от кэша). CACHE_URL задан => level 4: кэш
// сессий обязателен к работе на старте — если он должен быть, но не
// поднимается, лучше не стартовать вслепую.
var cache *sessionCache
if cacheURL := secret("CACHE_URL", ""); cacheURL != "" {
cache, err = newSessionCache(cacheURL)
if err != nil {
slog.Error("не удалось подключиться к Redis/Valkey", "err", err)
os.Exit(1)
}
defer cache.Close()
slog.Info("кэш сессий включён", "cache_url_set", true)
} else {
slog.Info("кэш сессий выключен: CACHE_URL не задан, работаем только с PostgreSQL")
}
ttlSeconds, err := strconv.Atoi(env("SESSION_TTL_SECONDS", "3600"))
if err != nil || ttlSeconds <= 0 {
slog.Error("SESSION_TTL_SECONDS должен быть положительным целым", "value", env("SESSION_TTL_SECONDS", "3600"))
os.Exit(1)
}
store := NewStore(db, cache, time.Duration(ttlSeconds)*time.Second)
var draining atomic.Bool
srv := &http.Server{
Addr: net.JoinHostPort(host, port),
Handler: (&api{store: store, draining: &draining}).routes(),
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 15 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
}
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
errCh := make(chan error, 1)
go func() {
slog.Info("listening", "addr", srv.Addr, "env", env("APP_ENV", "lab"))
errCh <- srv.ListenAndServe()
}()
select {
case err := <-errCh:
slog.Error("server failed", "err", err)
os.Exit(1)
case <-ctx.Done():
}
// Shutdown сразу закрывает listener (новые соединения не принимаются)
// и ждёт завершения текущих запросов. Бюджет 8 с < 10 с из рубрики.
// db/cache закрываются через defer выше, после возврата из main.
draining.Store(true)
slog.Info("shutting down")
sctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
defer cancel()
if err := srv.Shutdown(sctx); err != nil {
slog.Warn("graceful shutdown timed out, forcing close", "err", err)
srv.Close()
}
slog.Info("stopped")
}
+57
View File
@@ -0,0 +1,57 @@
package main
import (
"database/sql"
"embed"
"errors"
"fmt"
"github.com/golang-migrate/migrate/v4"
"github.com/golang-migrate/migrate/v4/database/postgres"
"github.com/golang-migrate/migrate/v4/source/iofs"
_ "github.com/jackc/pgx/v5/stdlib" // регистрирует pgx как database/sql-драйвер "pgx" — нужен только здесь
)
// Миграции запекаются в бинарь: один артефакт, нечему потеряться между
// образом и файловой системой хоста.
//
//go:embed migrations/*.sql
var migrationsFS embed.FS
// runMigrations применяет все непримененные миграции через golang-migrate
// (стандартная, проверенная библиотека для этого — а не самодельный раннер).
//
// golang-migrate работает поверх интерфейса database/sql, которого у pgxpool
// нет (это "родной" pgx-пул, а не database/sql.DB). Поэтому здесь открывается
// ОТДЕЛЬНОЕ, короткоживущее *sql.DB через pgx-овский stdlib-адаптер — только
// на время применения миграций при старте; рабочий пул приложения (pgxpool.Pool,
// см. db.go) для обычных запросов — он отдельный и остаётся на всё время жизни
// процесса.
func runMigrations(dsn string) error {
db, err := sql.Open("pgx", dsn)
if err != nil {
return fmt.Errorf("открыть соединение для миграций: %w", err)
}
defer db.Close()
srcDriver, err := iofs.New(migrationsFS, "migrations")
if err != nil {
return fmt.Errorf("источник миграций: %w", err)
}
dbDriver, err := postgres.WithInstance(db, &postgres.Config{})
if err != nil {
return fmt.Errorf("драйвер БД для migrate: %w", err)
}
m, err := migrate.NewWithInstance("iofs", srcDriver, "postgres", dbDriver)
if err != nil {
return fmt.Errorf("инициализация migrate: %w", err)
}
defer m.Close()
if err := m.Up(); err != nil && !errors.Is(err, migrate.ErrNoChange) {
return fmt.Errorf("применение миграций: %w", err)
}
return nil
}
+5
View File
@@ -0,0 +1,5 @@
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;
+71
View File
@@ -0,0 +1,71 @@
-- Лаб2: пользователи, чаты, участники, сообщения, сессии.
-- Транзакционные границы и обоснование индексов — см. db/README.md.
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_not_blank CHECK (btrim(display_name) <> '')
);
-- Уникальность username на уровне БД — это и есть защита от гонки двух
-- параллельных регистраций одного имени: кто вставился первым, тот и
-- выиграл, второй получает unique_violation (23505) -> 409 conflict.
CREATE UNIQUE INDEX users_username_key ON users (username);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT chats_title_not_blank CHECK (btrim(title) <> '')
);
-- Участники чата: отдельная таблица связи, а не массив в chats —
-- позволяет FK-проверку существования пользователя силами БД и
-- normалized lookup "мои чаты" через индекс по user_id.
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
PRIMARY KEY (chat_id, user_id)
);
-- "Чаты пользователя" читаются по user_id, а не по chat_id (который ведущий
-- столбец первичного ключа) — нужен отдельный индекс в обратном порядке.
CREATE INDEX chat_members_user_id_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id) ON DELETE RESTRICT,
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT messages_text_not_blank CHECK (btrim(text) <> '')
);
-- Ключевой индекс лабы: keyset-пагинация истории чата делает
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
-- ORDER BY created_at, id LIMIT $4
-- Композитный индекс (chat_id, created_at, id) превращает это в range scan
-- по одному чату вместо full scan всей таблицы сообщений на каждую
-- страницу. EXPLAIN (ANALYZE, BUFFERS) на ≥10k строк — в evidence/.
CREATE INDEX messages_chat_created_idx ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
-- Храним не сам токен, а SHA-256 от него: утечка таблицы сессий не
-- выдаёт действующие bearer-токены напрямую (та же логика, что и для
-- паролей — только тут это "ещё один слой", а не KDF: токен сам по
-- себе уже 256 бит случайности).
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz
);
-- Периодическая очистка истёкших/отозванных сессий (не обязательна для
-- корректности — expires_at/revoked_at проверяются в каждом запросе —
-- но нужна, чтобы таблица не росла бесконечно).
CREATE INDEX sessions_expires_at_idx ON sessions (expires_at);
+1
View File
@@ -0,0 +1 @@
DROP TABLE IF EXISTS message_idempotency;
+7
View File
@@ -0,0 +1,7 @@
CREATE TABLE message_idempotency (
user_id uuid NOT NULL REFERENCES users(id), chat_id uuid NOT NULL REFERENCES chats(id),
key text NOT NULL, body_fingerprint text NOT NULL,
message_id uuid REFERENCES messages(id), expires_at timestamptz NOT NULL,
PRIMARY KEY(user_id,chat_id,key)
);
CREATE INDEX message_idempotency_expiry_idx ON message_idempotency(expires_at);
+636
View File
@@ -0,0 +1,636 @@
package main
import (
"context"
"encoding/base64"
"errors"
"log/slog"
"strings"
"sync"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
)
// Фиксированная ширина (6 знаков) => строки курсора сравниваются
// лексикографически так же, как время. Формат: RFC 3339 UTC с "Z".
const tsLayout = "2006-01-02T15:04:05.000000Z"
var (
errConflict = errors.New("conflict")
errInvalid = errors.New("invalid")
errNotFound = errors.New("not found")
errUnauthorized = errors.New("unauthorized")
)
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt string `json:"created_at"`
}
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt string `json:"created_at"`
}
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt string `json:"created_at"`
}
type Session struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt string `json:"expires_at"`
User User `json:"user"`
}
func formatTS(t time.Time) string { return t.UTC().Format(tsLayout) }
// Store — тонкая обёртка над *pgxpool.Pool (+ опциональный Redis-кэш сессий).
// Пул соединений и его лимиты настраиваются в openPool; здесь только запросы.
type Store struct {
db *pgxpool.Pool
cache *sessionCache // nil => кэш не настроен, работаем только с Postgres
sessionTTL time.Duration
revoked sync.Map // string(token_hash) -> time.Time: см. denyLocally
}
func NewStore(db *pgxpool.Pool, cache *sessionCache, sessionTTL time.Duration) *Store {
return &Store{db: db, cache: cache, sessionTTL: sessionTTL}
}
// isUniqueViolation: SQLSTATE 23505 — PostgreSQL error code для unique_violation.
func isUniqueViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23505"
}
// isForeignKeyViolation: SQLSTATE 23503 — ссылка на несуществующую строку
// (например, неизвестный user_id в chat_members).
func isForeignKeyViolation(err error) bool {
var pgErr *pgconn.PgError
return errors.As(err, &pgErr) && pgErr.Code == "23503"
}
func (s *Store) CreateUser(ctx context.Context, username, displayName, passwordHash string) (User, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
u := User{ID: newUUID(), Username: username, DisplayName: displayName}
var createdAt time.Time
err := s.db.QueryRow(ctx,
`INSERT INTO users (id, username, display_name, password_hash)
VALUES ($1, $2, $3, $4) RETURNING created_at`,
u.ID, username, displayName, passwordHash).Scan(&createdAt)
if err != nil {
if isUniqueViolation(err) {
return User{}, errConflict
}
return User{}, err
}
u.CreatedAt = formatTS(createdAt)
return u, nil
}
func (s *Store) GetUser(ctx context.Context, id string) (User, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var u User
var createdAt time.Time
err := s.db.QueryRow(ctx,
`SELECT id, username, display_name, created_at FROM users WHERE id = $1`,
id).Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt)
if errors.Is(err, pgx.ErrNoRows) {
return User{}, errNotFound
}
if err != nil {
return User{}, err
}
u.CreatedAt = formatTS(createdAt)
return u, nil
}
// AuthenticateUser проверяет Basic username:password. Несуществующий
// username и неверный пароль дают одну и ту же ошибку — чтобы ответ не
// раскрывал, какой username существует.
func (s *Store) AuthenticateUser(ctx context.Context, username, password string) (User, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var u User
var createdAt time.Time
var hash string
err := s.db.QueryRow(ctx,
`SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1`,
username).Scan(&u.ID, &u.Username, &u.DisplayName, &hash, &createdAt)
if errors.Is(err, pgx.ErrNoRows) {
return User{}, errUnauthorized
}
if err != nil {
return User{}, err
}
ok, err := verifyPassword(hash, password)
if err != nil || !ok {
return User{}, errUnauthorized
}
u.CreatedAt = formatTS(createdAt)
return u, nil
}
// CreateChat — атомарная составная операция: вставка чата и всех строк
// членства в одной транзакции. Неизвестный участник нарушает FK на
// chat_members.user_id -> откат целиком, ни чат, ни частичный список
// участников не остаются в БД.
func (s *Store) CreateChat(ctx context.Context, title string, memberIDs []string) (Chat, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
tx, err := s.db.Begin(ctx)
if err != nil {
return Chat{}, err
}
defer tx.Rollback(ctx) //nolint:errcheck — не влияет после успешного Commit
c := Chat{ID: newUUID(), Title: title, MemberIDs: memberIDs}
var createdAt time.Time
if err := tx.QueryRow(ctx,
`INSERT INTO chats (id, title) VALUES ($1, $2) RETURNING created_at`,
c.ID, title).Scan(&createdAt); err != nil {
return Chat{}, err
}
if _, err := tx.Exec(ctx,
`INSERT INTO chat_members (chat_id, user_id)
SELECT $1, unnest($2::uuid[])`,
c.ID, memberIDs); err != nil {
if isForeignKeyViolation(err) {
return Chat{}, errInvalid
}
return Chat{}, err
}
if err := tx.Commit(ctx); err != nil {
return Chat{}, err
}
c.CreatedAt = formatTS(createdAt)
return c, nil
}
// GetChat возвращает чат, только если userID — его участник; чужой и
// несуществующий чат неразличимы (оба errNotFound — так и задано в контракте).
func (s *Store) GetChat(ctx context.Context, userID, chatID string) (Chat, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var c Chat
var createdAt time.Time
err := s.db.QueryRow(ctx,
`SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members cm ON cm.chat_id = c.id AND cm.user_id = $2
WHERE c.id = $1`,
chatID, userID).Scan(&c.ID, &c.Title, &createdAt)
if errors.Is(err, pgx.ErrNoRows) {
return Chat{}, errNotFound
}
if err != nil {
return Chat{}, err
}
members, err := s.chatMembers(ctx, c.ID)
if err != nil {
return Chat{}, err
}
c.MemberIDs = members
c.CreatedAt = formatTS(createdAt)
return c, nil
}
func (s *Store) chatMembers(ctx context.Context, chatID string) ([]string, error) {
rows, err := s.db.Query(ctx,
`SELECT user_id FROM chat_members WHERE chat_id = $1`, chatID)
if err != nil {
return nil, err
}
defer rows.Close()
// make(..., 0), не var out []string: nil-слайс маршалится в JSON как
// null, а не [] — контракт (и smoke-тест) ожидает массив даже пустой.
out := make([]string, 0)
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
out = append(out, id)
}
return out, rows.Err()
}
func (s *Store) AddMessage(ctx context.Context, userID, chatID, text string) (Message, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var isMember bool
if err := s.db.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID).Scan(&isMember); err != nil {
return Message{}, err
}
if !isMember {
return Message{}, errNotFound
}
m := Message{ID: newUUID(), ChatID: chatID, SenderID: userID, Text: text}
var createdAt time.Time
err := s.db.QueryRow(ctx,
`INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, clock_timestamp()) RETURNING created_at`,
m.ID, chatID, userID, text).Scan(&createdAt)
if err != nil {
return Message{}, err
}
m.CreatedAt = formatTS(createdAt)
return m, nil
}
// ListMessages — keyset-пагинация: fetch limit+1 строк, чтобы одним запросом
// узнать и страницу, и есть ли следующая, без отдельного COUNT(*).
func (s *Store) ListMessages(ctx context.Context, userID, chatID string, after *pos, limit int) ([]Message, bool, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var isMember bool
if err := s.db.QueryRow(ctx,
`SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2)`,
chatID, userID).Scan(&isMember); err != nil {
return nil, false, err
}
if !isMember {
return nil, false, errNotFound
}
var rows pgx.Rows
var err error
if after == nil {
rows, err = s.db.Query(ctx,
`SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1
ORDER BY created_at, id
LIMIT $2`,
chatID, limit+1)
} else {
rows, err = s.db.Query(ctx,
`SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2::timestamptz, $3::uuid)
ORDER BY created_at, id
LIMIT $4`,
chatID, after.ts, after.id, limit+1)
}
if err != nil {
return nil, false, err
}
defer rows.Close()
// make(..., 0), не var out []Message: nil-слайс маршалится в JSON как
// null, а не [] — "items" в ответе должен быть массивом даже пустым.
out := make([]Message, 0)
for rows.Next() {
var m Message
var createdAt time.Time
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &createdAt); err != nil {
return nil, false, err
}
m.CreatedAt = formatTS(createdAt)
out = append(out, m)
}
if err := rows.Err(); err != nil {
return nil, false, err
}
more := len(out) > limit
if more {
out = out[:limit]
}
return out, more, nil
}
func (s *Store) ListChats(ctx context.Context, userID string, after *pos, limit int) ([]Chat, bool, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
var rows pgx.Rows
var err error
if after == nil {
rows, err = s.db.Query(ctx,
`SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = $1
ORDER BY c.created_at, c.id
LIMIT $2`,
userID, limit+1)
} else {
rows, err = s.db.Query(ctx,
`SELECT c.id, c.title, c.created_at
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
WHERE cm.user_id = $1 AND (c.created_at, c.id) > ($2::timestamptz, $3::uuid)
ORDER BY c.created_at, c.id
LIMIT $4`,
userID, after.ts, after.id, limit+1)
}
if err != nil {
return nil, false, err
}
defer rows.Close()
// make(..., 0), не var out []Chat: та же причина, что в ListMessages.
out := make([]Chat, 0)
for rows.Next() {
var c Chat
var createdAt time.Time
if err := rows.Scan(&c.ID, &c.Title, &createdAt); err != nil {
return nil, false, err
}
c.CreatedAt = formatTS(createdAt)
out = append(out, c)
}
if err := rows.Err(); err != nil {
return nil, false, err
}
more := len(out) > limit
if more {
out = out[:limit]
}
// member_ids для каждого чата страницы — одним batched-запросом, не N+1.
if len(out) > 0 {
ids := make([]string, len(out))
for i, c := range out {
ids[i] = c.ID
}
memberRows, err := s.db.Query(ctx,
`SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY($1::uuid[])`,
ids)
if err != nil {
return nil, false, err
}
members := make(map[string][]string, len(out))
for memberRows.Next() {
var chatID, memberID string
if err := memberRows.Scan(&chatID, &memberID); err != nil {
memberRows.Close()
return nil, false, err
}
members[chatID] = append(members[chatID], memberID)
}
memberRows.Close()
if err := memberRows.Err(); err != nil {
return nil, false, err
}
for i := range out {
out[i].MemberIDs = members[out[i].ID]
}
}
return out, more, nil
}
// --- сессии ------------------------------------------------------------
// CreateSession выдаёт новый opaque bearer-токен поверх уже
// аутентифицированного пользователя (см. AuthenticateUser) и кладёт его в
// Postgres (источник истины) и, если настроен, в кэш.
func (s *Store) CreateSession(ctx context.Context, u User) (Session, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
token, err := newSessionToken()
if err != nil {
return Session{}, err
}
hash := hashToken(token)
expiresAt := time.Now().UTC().Add(s.sessionTTL)
if _, err := s.db.Exec(ctx,
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, $3)`,
hash, u.ID, expiresAt); err != nil {
return Session{}, err
}
// Avoid caching positive auth decisions across replicas.
_ = expiresAt
return Session{
Token: token,
TokenType: "Bearer",
ExpiresAt: formatTS(expiresAt),
User: u,
}, nil
}
// ValidateSession — горячий путь: сначала кэш (если настроен), затем
// Postgres. Любой сбой кэша (промах ИЛИ ошибка связи) просто идёт в
// Postgres — отказ Redis никогда не трактуется как "токен валиден" и
// никогда не трактуется как "запрос анонимный, но пропустим".
func (s *Store) ValidateSession(ctx context.Context, token string) (User, bool, error) {
ctx, cancel := withTimeout(ctx)
defer cancel()
hash := hashToken(token)
// Multi-replica correctness: never trust a positive Redis cache hit.
// PostgreSQL is authoritative for revocation on every request.
var u User
var createdAt, expiresAt time.Time
err := s.db.QueryRow(ctx,
`SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()`,
hash).Scan(&u.ID, &u.Username, &u.DisplayName, &createdAt, &expiresAt)
if errors.Is(err, pgx.ErrNoRows) {
return User{}, false, nil
}
if err != nil {
return User{}, false, err
}
u.CreatedAt = formatTS(createdAt)
// Avoid caching positive auth decisions across replicas.
_ = expiresAt
return u, true, nil
}
func (s *Store) RevokeSession(ctx context.Context, token string) error {
ctx, cancel := withTimeout(ctx)
defer cancel()
hash := hashToken(token)
if _, err := s.db.Exec(ctx,
`UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL`,
hash); err != nil {
return err
}
// All replicas check PostgreSQL, so a failed Redis DEL cannot resurrect a token.
_ = s.cache.invalidate(ctx, hash, s.sessionTTL)
return nil
}
// denyLocally/locallyRevoked — in-memory deny-list отозванных токенов на
// случай, когда Redis не позволил инвалидировать запись. Записи живут не
// дольше срока сессии и вычищаются при добавлении новых.
func (s *Store) denyLocally(hash []byte, until time.Time) {
now := time.Now()
s.revoked.Range(func(k, v any) bool {
if now.After(v.(time.Time)) {
s.revoked.Delete(k)
}
return true
})
s.revoked.Store(string(hash), until)
}
// ReconcileRevoked вызывается при старте процесса, ДО приёма запросов.
// Локальный deny-list и надгробия живут недолго или только в памяти и не
// переживают рестарт API, а запись в Redis, которую logout не смог
// инвалидировать, — переживает. Источник истины об отзыве — Postgres
// (revoked_at), поэтому для каждой отозванной и ещё не истёкшей сессии
// повторяем инвалидацию кэша; если Redis по-прежнему не даёт ни DEL, ни
// SET — токен заносится в локальный deny-list уже из БД. Ошибка чтения из
// Postgres фатальна для старта: без неё нельзя гарантировать, что отозванный
// токен не оживёт из кэша.
func (s *Store) ReconcileRevoked(ctx context.Context) error {
if s.cache == nil {
return nil
}
rows, err := s.db.Query(ctx,
`SELECT token_hash, expires_at FROM sessions
WHERE revoked_at IS NOT NULL AND expires_at > now()`)
if err != nil {
return err
}
type revokedSession struct {
hash []byte
expiresAt time.Time
}
var revoked []revokedSession
for rows.Next() {
var r revokedSession
if err := rows.Scan(&r.hash, &r.expiresAt); err != nil {
rows.Close()
return err
}
revoked = append(revoked, r)
}
rows.Close() // освобождаем соединение до походов в Redis
if err := rows.Err(); err != nil {
return err
}
for _, r := range revoked {
if !s.cache.invalidate(ctx, r.hash, time.Until(r.expiresAt)) {
s.denyLocally(r.hash, r.expiresAt)
}
}
slog.Info("отозванные сессии сверены с кэшем", "count", len(revoked))
return nil
}
func (s *Store) locallyRevoked(hash []byte) bool {
v, ok := s.revoked.Load(string(hash))
if !ok {
return false
}
if time.Now().After(v.(time.Time)) {
s.revoked.Delete(string(hash))
return false
}
return true
}
func (s *Store) Ready(ctx context.Context) error {
ctx, cancel := withTimeout(ctx)
defer cancel()
return s.db.Ping(ctx)
}
// --- keyset cursor -----------------------------------------------------
// pos — позиция последнего отданного элемента. Курсор привязан к scope
// ("m:<chat_id>" или "c:<user_id>"), поэтому курсор чужого чата даёт 400.
type pos struct{ ts, id string }
func encodeCursor(scope, ts, id string) string {
return base64.RawURLEncoding.EncodeToString([]byte(scope + "|" + ts + "|" + id))
}
func decodeCursor(scope, raw string) (*pos, bool) {
b, err := base64.RawURLEncoding.DecodeString(raw)
if err != nil {
return nil, false
}
parts := strings.Split(string(b), "|")
if len(parts) != 3 || parts[0] != scope || parts[1] == "" || parts[2] == "" {
return nil, false
}
// Непустые строки — не значит валидные. ts должен быть настоящей меткой
// времени нашего формата, id — настоящим UUID: без этого структурно
// похожий, но мусорный курсор тихо дал бы пустую страницу вместо 400.
if _, err := time.Parse(tsLayout, parts[1]); err != nil {
return nil, false
}
if !uuidRe.MatchString(parts[2]) {
return nil, false
}
return &pos{ts: parts[1], id: parts[2]}, true
}
func (s *Store) AddMessageIdempotent(parent context.Context, userID, chatID, key, body string) (Message, error) {
ctx, cancel := context.WithTimeout(parent, 8*time.Second)
defer cancel()
tx, err := s.db.Begin(ctx)
if err != nil {
return Message{}, err
}
defer tx.Rollback(ctx)
var member bool
if err = tx.QueryRow(ctx, `SELECT EXISTS(SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2)`, chatID, userID).Scan(&member); err != nil {
return Message{}, err
}
if !member {
return Message{}, errNotFound
}
// The request fingerprint is canonical for lab3: text plus the normalized empty attachment list.
fingerprint := body
var existingID *string
var oldFingerprint string
err = tx.QueryRow(ctx, `INSERT INTO message_idempotency (user_id,chat_id,key,body_fingerprint,message_id,expires_at)
VALUES ($1,$2,$3,$4,NULL,now()+interval '24 hours')
ON CONFLICT (user_id,chat_id,key) DO UPDATE SET key=EXCLUDED.key
RETURNING message_id,body_fingerprint`, userID, chatID, key, fingerprint).Scan(&existingID, &oldFingerprint)
if err != nil {
return Message{}, err
}
if oldFingerprint != fingerprint {
return Message{}, errConflict
}
if existingID != nil {
var m Message
var t time.Time
err = tx.QueryRow(ctx, `SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE id=$1`, *existingID).Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &t)
if err != nil {
return Message{}, err
}
m.CreatedAt = formatTS(t)
if err = tx.Commit(ctx); err != nil {
return Message{}, err
}
return m, nil
}
m := Message{ID: newUUID(), ChatID: chatID, SenderID: userID, Text: body}
var t time.Time
err = tx.QueryRow(ctx, `INSERT INTO messages(id,chat_id,sender_id,text,created_at) VALUES($1,$2,$3,$4,clock_timestamp()) RETURNING created_at`, m.ID, chatID, userID, body).Scan(&t)
if err != nil {
return Message{}, err
}
m.CreatedAt = formatTS(t)
_, err = tx.Exec(ctx, `UPDATE message_idempotency SET message_id=$4 WHERE user_id=$1 AND chat_id=$2 AND key=$3`, userID, chatID, key, m.ID)
if err != nil {
return Message{}, err
}
if err = tx.Commit(ctx); err != nil {
return Message{}, err
}
return m, nil
}
+78
View File
@@ -0,0 +1,78 @@
"""Concurrent Idempotency-Key test for lab 3."""
from concurrent.futures import ThreadPoolExecutor
import threading
import uuid
from client import Client, Failure, arguments, check, run
def main():
args = arguments("Concurrent idempotency test")
client = Client(args.base_url, args.ca_file)
alice, bob, eve, chat = client.bootstrap()
key = uuid.uuid4().hex
message_text = "concurrent-idempotency-" + uuid.uuid4().hex
path = f"/api/v1/chats/{chat['id']}/messages"
workers = 20
barrier = threading.Barrier(workers)
def send(_):
local = Client(args.base_url, args.ca_file, timeout=10)
barrier.wait()
response = local.message(
alice,
chat,
message_text,
key=key,
)
return {
"id": response["json"]["id"],
"instance": response["headers"].get("X-Instance-Id"),
"message": response["json"],
}
with ThreadPoolExecutor(max_workers=workers) as executor:
results = list(executor.map(send, range(workers)))
ids = {r["id"] for r in results}
instances = {r["instance"] for r in results if r["instance"]}
print(f"Concurrent requests: {workers}")
print(f"Unique message IDs: {len(ids)}")
print(f"Observed API instances: {len(instances)}")
print(f"Instance IDs: {sorted(instances)}")
check(len(ids) == 1, "duplicate messages were created")
check(
all(r["message"] == results[0]["message"] for r in results),
"idempotency responses differ",
)
check(len(instances) >= 2, "requests did not reach two API instances")
# Verify that the stored chat history contains exactly one copy.
history = client.call(
"GET",
path + "?limit=100",
actor=alice,
schema="MessagePage",
)["json"]
matches = [
item for item in history["items"]
if item["text"] == message_text
]
check(len(matches) == 1, "chat history contains duplicate messages")
check(matches[0]["id"] in ids, "stored message ID differs")
print("PASS: concurrent idempotency across API replicas")
if __name__ == "__main__":
run(main)