Implement lab3 load balancing and failover

This commit is contained in:
Ilia Sokolov
2026-10-31 17:19:05 +03:00
parent 0ab3a341aa
commit 06d47fbb5b
27 changed files with 2438 additions and 25 deletions
+9
View File
@@ -9,5 +9,14 @@ DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# Число реплик API (Compose deploy.replicas).
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
# --- добавлено в lab2/lab3 ---
PUBLISHED_PORT=8080
POSTGRES_DB=messenger
POSTGRES_USER=messenger
DB_MAX_CONNS=10
# Время «не готов, но ещё обслуживаю» после SIGTERM перед закрытием listener.
SHUTDOWN_DRAIN_SECONDS=1
+26
View File
@@ -0,0 +1,26 @@
# syntax=docker/dockerfile:1
# Сборка из исходников; образ-сервер преподавателя не используется.
FROM golang:1.23.8-bookworm AS build
WORKDIR /src
# Сначала манифесты зависимостей: слой кэшируется, пока go.mod/go.sum не менялись.
COPY go.mod go.sum ./
RUN go mod download && go mod verify
COPY *.go ./
COPY migrations ./migrations
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o /out/messenger .
# Пустой runtime-образ: один статический бинарник, нет shell и пакетного менеджера.
FROM scratch
COPY --from=build /out/messenger /messenger
ENV APP_HOST=0.0.0.0 \
APP_PORT=8080
EXPOSE 8080
# Не root: числовой UID достаточен, /etc/passwd в scratch не нужен.
USER 65532:65532
# В scratch нет curl, поэтому проверку выполняет сам бинарник (GET /health/ready).
HEALTHCHECK --interval=10s --timeout=4s --start-period=5s --retries=3 CMD ["/messenger", "healthcheck"]
# PID 1 — сам процесс; он корректно завершается по SIGTERM (graceful shutdown).
ENTRYPOINT ["/messenger"]
CMD ["serve"]
+18 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test load test-persistence test-failover secrets up down logs go-test
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -28,3 +28,20 @@ test-persistence:
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
# --- lab3: единый запуск (Docker Compose v2): LB nginx + API x2 + PostgreSQL ---
secrets:
sh scripts/init-secrets.sh
up: secrets
docker compose up -d --build
# Остановка БЕЗ удаления volumes. Намеренное удаление учебных данных: docker compose down -v
down:
docker compose down
logs:
docker compose logs --tail=100 lb api postgres
go-test:
go test -count=1 ./...
+207 -24
View File
@@ -1,37 +1,220 @@
# Отчёт — лабораторная 3
# Отчёт по лабораторной работе № 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
**Дисциплина:** Высоконагруженные системы
**Тема:** Балансировка нагрузки и отказ API-реплики
**Факультет:** Факультет ИТ
**Группа:** БВТ2302
**Студент:** Соколов Илья Сергеевич
**Целевая оценка:** 3
**Дата проверки:** 31.10.2026
**Репозиторий / commit / Pull Request:** сведения о публикации не предоставлены; заполнить после отправки в GitHub.
## Запуск из чистого clone
## 1. Цель работы
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Развернуть приложение с не менее чем двумя взаимозаменяемыми экземплярами API за единой точкой входа, общим хранилищем данных и сессий. Проверить корректность работы API, сохранение данных после перезапуска компонентов, отказоустойчивость при остановке одной реплики и идемпотентность повторных запросов.
## Архитектура и решения
## 2. Используемые технологии
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- **Go 1.23** — реализация HTTP API.
- **PostgreSQL 16.9** — общее хранилище пользователей, сообщений, сессий и ключей идемпотентности.
- **Nginx 1.27.5** — балансировщик и единая точка входа.
- **Docker Desktop / Docker Compose** — сборка, запуск и управление контейнерами.
- **Python 3.12** — выполнение публичных проверок.
- **Windows PowerShell** — запуск команд на локальной машине.
## Доказательства критериев
## 3. Архитектура приложения
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
```text
Клиент (http://localhost:18080)
|
v
Nginx (lb:80)
/ \
v v
API-1 API-2
\ /
v v
PostgreSQL
(volume pgdata)
```
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Стенд запускается через `compose.yaml`. Nginx публикует **только один порт на локальном компьютере** — `127.0.0.1:18080`, а обе API-реплики доступны через внутреннюю сеть Docker без отдельной публикации портов. Внутри Docker API продолжает прослушивать порт `8080`.
## Эксперименты и отказы
API не хранит критичное для корректности состояние локально: данные приложения, сессии и ключи идемпотентности находятся в общей БД PostgreSQL. Поэтому запросы одной пользовательской сессии могут обслуживаться разными репликами без повторной авторизации. Sticky sessions не используются.
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Миграции выполняются отдельным одноразовым сервисом `migrate`, который стартует после готовности PostgreSQL. API начинает работу после успешного выполнения миграций. Статус `Exited (0)` для `migrate` после завершения — штатный.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
**Основные решения:**
## Ограничения и следующие шаги
- **Балансировка:** Nginx использует внутренний DNS Docker (`api`) и `resolver 127.0.0.11 valid=1s`; настроены ограничения по времени ожидания соединения и повтор при сетевых ошибках/ошибках шлюза.
- **Readiness:** endpoint `GET /health/ready` проверяет готовность сервиса.
- **Идентификация реплик:** заголовок `X-Instance-Id` позволяет наблюдать, какой экземпляр обработал запрос.
- **Graceful shutdown:** при SIGTERM сервис перестаёт считаться готовым, выдерживает период `SHUTDOWN_DRAIN_SECONDS=1` и завершает обработку текущих запросов.
- **Идемпотентность:** запрос отправки сообщения использует `Idempotency-Key`; запись ключа и сообщения выполняется в одной транзакции PostgreSQL. Повтор с тем же ключом и телом возвращает сохранённый результат, попытка использовать ключ с другим телом отклоняется.
- **Хранение данных:** Docker volume `pgdata` сохраняется при обычных перезапусках контейнеров.
- **Защита:** заданы лимиты CPU/RAM, у API включены `read_only`, `cap_drop: ALL` и запрет повышения привилегий.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
## 4. Запуск лабораторной работы
В локальной среде Windows порт `8080` оказался недоступен для публикации Docker (`bind: An attempt was made to access a socket in a way forbidden by its access permissions`). Поэтому в локальном `.env` был установлен `PUBLISHED_PORT=18080`. Это изменяет **только внешний порт балансировщика**, а не внутренний порт API. Файл `.env`, как и файлы из `secrets/`, не включается в репозиторий.
Использованный каталог проекта:
```text
D:\Study\sem_7\Высоконагруженные системы\Лабы\3\mtusi2026lab3-main
```
**Команды для воспроизведения запуска в PowerShell:**
```powershell
cd "D:\Study\sem_7\Высоконагруженные системы\Лабы\3\mtusi2026lab3-main"
# Создаёт локальные secrets/ и .env, если их ещё нет.
powershell -ExecutionPolicy Bypass -File scripts\init-secrets.ps1
# Однократно укажите в .env: PUBLISHED_PORT=18080
# На компьютере без конфликта портов допустимо оставить 8080.
docker compose up -d --build
docker compose ps
curl.exe http://localhost:18080/health/ready
```
**Фактически полученный ответ readiness:**
```json
{"status":"ok"}
```
После запуска были здоровы `mtusi-lab3-postgres-1`, `mtusi-lab3-api-1` и `mtusi-lab3-api-2`; балансировщик `mtusi-lab3-lb-1` работал с привязкой `127.0.0.1:18080->80/tcp`. После проверки отказоустойчивости первая реплика была восстановлена командой `docker compose up -d`, и обе API-реплики вновь получили статус `Healthy`.
## 5. Проверки и результаты
Все приведённые ниже результаты получены в PowerShell **31.10.2026**. Для Python в Windows использован параметр `-X utf8`, поскольку без него чтение `lab.json` завершалось `UnicodeDecodeError` из-за системной кодировки `cp1252`.
### 5.1. Базовый сценарий API (smoke)
```powershell
python -X utf8 tests\smoke.py --base-url http://localhost:18080
```
Результат:
```text
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
```
**Вывод:** сквозной публичный сценарий API пройден, включая стандартные проверки повторной отправки сообщения с тем же ключом, конфликт с другим телом и отсутствие обязательного ключа. Данный тест сам по себе не доказывает наличие двух работающих контейнеров или поведение системы при отказе.
### 5.2. Сохранность данных и сессии (persistence)
```powershell
python -X utf8 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:18080
```
Результат:
```text
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
```
**Вывод:** после выполнения `restart.cmd` подтверждённые данные сохранились, а существующий токен сессии остался действительным. Скрипт перезапускает LB, API и PostgreSQL без удаления volume. Для доказательства реального объёма перезапуска дополнительно требуются состояния контейнеров до/после выполнения скрипта.
### 5.3. Остановка одной реплики (failover)
```powershell
python -X utf8 tests\resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://localhost:18080
```
Результат:
```text
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 8, "failed_attempts": 0, "first_recovery_seconds": 4.203}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
```
| Показатель | Полученное значение |
| --- | ---: |
| Различных API-реплик до отказа | **2** |
| Успешных записей во время теста | **8** |
| Неудачных попыток | **0** |
| Время до первой успешной записи после начала отказа | **4,203 с** |
| Допустимое время восстановления записи по критерию лабораторной | **не более 10 с** |
| Результат теста | **PASS** |
Дополнительно выполнена команда:
```powershell
docker ps -a --filter label=com.docker.compose.service=api
```
Состояние непосредственно после теста:
```text
mtusi-lab3-api-2 Up (healthy)
mtusi-lab3-api-1 Exited (0)
```
Таким образом, одна реплика (`api-1`) была действительно остановлена, вторая (`api-2`) осталась работоспособной, а проверка сохранности данных и прежней сессии завершилась успешно. После эксперимента выполнено:
```powershell
docker compose up -d
```
После восстановления обе API-реплики получили статус `Healthy`.
## 6. Соответствие критериям лабораторной
| Критерий | Подтверждение | Статус |
| --- | --- | --- |
| Запуск через Docker Compose, одна точка входа | `docker compose up -d --build`, опубликован только порт LB | Подтверждено |
| Не менее двух API-реплик и общее хранилище | Две здоровые API-реплики; `observed_instances_before: 2` | Подтверждено |
| Работа одного пользователя через разные реплики | `resilience.py` наблюдал два `X-Instance-Id` | Подтверждено тестом |
| Публичный сквозной сценарий API | `smoke.py` — PASS | Подтверждено |
| Сохранность данных после рестарта | `persistence` — PASS | Подтверждено тестом |
| Работа при остановке одной реплики, восстановление записи за ≤10 с | `failover` — PASS; 4,203 с; 0 ошибок | Подтверждено для `api-1` |
| Сохранность данных и прежнего токена при отказе | `failover` — PASS | Подтверждено тестом |
| Идемпотентные повторы запроса | Публичный smoke проверяет повтор и конфликты; failover проверяет безопасность неопределённого повтора | Базовые проверки пройдены |
| Одновременные POST с одним ключом через разные реплики | Отдельного протокола параллельных запросов пока нет | Требует отдельного доказательства |
| Остановка второй реплики при работающей первой | Повторный независимый опыт не зафиксирован | Требует отдельного доказательства |
| Commit / PR и приложенные артефакты evidence | Ссылки и файлы не предоставлены | Требует оформления |
## 7. Особенности эксперимента и ограничения
1. **PostgreSQL и Nginx остаются единичными точками отказа.** Данный эксперимент подтверждает устойчивость к отказу одной API-реплики, а не отказоустойчивость всех компонентов или физического узла.
2. **Замер 4,203 с** — время до первой успешной записи после начала failover hook, а не полное время перезапуска приложения или узла.
3. **Автоматические проверки не заменяют доказательства действий оператора.** Для защиты полезно сохранить вывод `docker compose ps`, состояния конкретной реплики до/после остановки и доказательства восстановления.
4. **Эксперимент с остановкой второй реплики отдельно не зафиксирован.** Повторить его после восстановления первой, если это требуется преподавателем.
5. **Конкурентные запросы с одним Idempotency-Key через разные реплики отдельно не измерялись.** Корректность базовой идемпотентности подтверждена smoke-тестом, но вывод о самостоятельной конкурентной проверке не делается.
6. **Внешний порт `18080`** относится к конкретному Windows-стенду. Для запуска на другой машине допустим стандартный порт `8080`, если он свободен.
## 8. Доказательства для репозитория
В каталоге `evidence/` рекомендуется сохранить небольшие обезличенные текстовые журналы:
- `smoke.txt` — вывод `smoke.py`;
- `persistence.txt` — вывод проверки сохранности;
- `failover.txt` — вывод проверки отказа и её метрики;
- `containers.txt` — перечень контейнеров и их состояний до отказа;
- `api-after-failover.txt` — состояния API-контейнеров после остановки;
- `api-after-restore.txt` — состояния после восстановления;
- отдельный протокол остановки второй реплики и конкурентных запросов, если выполнены.
**Примечание:** перечисленные имена — рекомендуемые артефакты. Наличие этих файлов в репозитории на момент составления отчёта не подтверждено. Секреты, `.env`, токены сессий, пароли и полные дампы БД сохранять в доказательства нельзя.
## 9. Вывод
В ходе лабораторной работы № 3 развернут стенд с балансировщиком Nginx, двумя взаимозаменяемыми API-репликами и общей PostgreSQL. Публичная проверка API, тест сохранности данных после перезапуска и тест отказа одной API-реплики **завершились успешно (PASS)**.
В тесте отказоустойчивости до остановки наблюдались две реплики. После остановки `api-1` система выполнила **8 успешных записей без зарегистрированных ошибок**, а первая успешная запись после начала отказа была зафиксирована через **4,203 секунды**, что удовлетворяет требованию восстановления не позднее 10 секунд. Подтверждённые сообщения и прежняя сессия сохранились, после чего остановленная реплика была восстановлена.
**Основные автоматические тесты пройдены.** Для полного комплекта материалов на защиту остаётся приложить журналы экспериментов, проверить отказ второй реплики, отдельно зафиксировать конкурентную идемпотентность и добавить ссылку на GitHub Pull Request.
## 10. Использованные материалы и помощь ИИ
- Исходное задание, API-контракт и публичные тесты лабораторной № 3 (`README.md`, `contracts/`, `tests/`).
- Собственная кодовая база лабораторной № 2 на Go, pgx и PostgreSQL, доработанная для лабораторной № 3.
- Конфигурация Docker Compose и Nginx с опорой на официальную документацию соответствующих инструментов.
- Claude Code использовался при доработке приложения и конфигураций; ChatGPT — при диагностике запуска и подготовке отчёта. Результаты проверок приведены из фактического вывода PowerShell.
+307
View File
@@ -0,0 +1,307 @@
package main
import (
"bytes"
"context"
"encoding/base64"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"strings"
"sync"
"testing"
"time"
)
// Тесты без БД всегда выполняются; тесты с БД — только если задан TEST_DATABASE_URL
// (пустая тестовая БД, например postgres://messenger@127.0.0.1:55432/messenger_test).
func TestCursorIsBoundToResource(t *testing.T) {
now := time.Now().UTC().Truncate(time.Microsecond)
c := encodeCursor("messages", "chat-a", now, newUUID())
if _, _, err := decodeCursor(c, "messages", "chat-a"); err != nil {
t.Fatalf("own cursor rejected: %v", err.message)
}
if _, _, err := decodeCursor(c, "messages", "chat-b"); err == nil || err.status != 400 {
t.Fatal("cursor of another chat must be rejected with 400")
}
if _, _, err := decodeCursor(c, "chats", "chat-a"); err == nil {
t.Fatal("cursor of another list kind must be rejected")
}
if _, _, err := decodeCursor("not-a-cursor", "messages", "chat-a"); err == nil {
t.Fatal("garbage cursor must be rejected")
}
}
func TestBasicParsing(t *testing.T) {
mk := func(raw string) *http.Request {
r := httptest.NewRequest("POST", "/", nil)
r.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(raw)))
return r
}
u, p, ok := parseBasic(mk("alice:pa:ss:wörd-ü"))
if !ok || u != "alice" || p != "pa:ss:wörd-ü" {
t.Fatalf("colon in password must be kept, got %q %q %v", u, p, ok)
}
if _, _, ok := parseBasic(mk("no-colon")); ok {
t.Fatal("credentials without colon must be rejected")
}
r := httptest.NewRequest("POST", "/", nil)
r.Header.Set("Authorization", "Basic !!!not-base64")
if _, _, ok := parseBasic(r); ok {
t.Fatal("invalid base64 must be rejected")
}
b := httptest.NewRequest("GET", "/", nil)
b.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("a:b")))
if _, ok := bearerToken(b); ok {
t.Fatal("Basic must not be accepted as Bearer")
}
}
func TestTokenAndPasswordHash(t *testing.T) {
token, hash := newToken()
if len(token) != 43 || len(hash) != 32 {
t.Fatalf("token must carry 256 bits (43 base64url chars), got %d", len(token))
}
if other, _ := newToken(); other == token {
t.Fatal("tokens must be unique")
}
h := newHasher(1)
hashed, err := h.hash(context.Background(), "correct horse battery")
if err != nil || len(hashed) < 40 || hashed[:10] != "$argon2id$" {
t.Fatalf("expected a PHC argon2id hash, got %q (%v)", hashed, err)
}
if ok, _ := h.verify(context.Background(), "correct horse battery", hashed); !ok {
t.Fatal("correct password must verify")
}
if ok, _ := h.verify(context.Background(), "wrong horse battery!", hashed); ok {
t.Fatal("wrong password must not verify")
}
}
// ---- тесты с PostgreSQL ----
type env struct {
srv *httptest.Server
store *Store
url string
}
func setup(t *testing.T, ttl int) *env {
t.Helper()
url := os.Getenv("TEST_DATABASE_URL")
if url == "" {
t.Skip("TEST_DATABASE_URL is not set")
}
ctx := context.Background()
if err := runMigrations(ctx, url); err != nil {
t.Fatal(err)
}
pool, err := newPool(ctx, url, 10)
if err != nil {
t.Fatal(err)
}
t.Cleanup(pool.Close)
store := &Store{pool: pool}
api := &API{store: store, hasher: newHasher(4), ttlSecs: ttl, reqLimit: 8 * time.Second}
srv := httptest.NewServer(api)
t.Cleanup(srv.Close)
return &env{srv: srv, store: store, url: url}
}
func (e *env) do(t *testing.T, method, path string, body any, headers map[string]string) (int, map[string]any, http.Header) {
t.Helper()
var rd *bytes.Reader
if body != nil {
raw, _ := json.Marshal(body)
rd = bytes.NewReader(raw)
} else {
rd = bytes.NewReader(nil)
}
req, _ := http.NewRequest(method, e.srv.URL+path, rd)
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
for k, v := range headers {
req.Header.Set(k, v)
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
var out map[string]any
_ = json.NewDecoder(resp.Body).Decode(&out)
return resp.StatusCode, out, resp.Header
}
func basic(user, pass string) map[string]string {
return map[string]string{"Authorization": "Basic " + base64.StdEncoding.EncodeToString([]byte(user+":"+pass))}
}
func bearer(token string) map[string]string {
return map[string]string{"Authorization": "Bearer " + token}
}
func (e *env) register(t *testing.T, name string) (id, pass string) {
t.Helper()
pass = "Passw0rd-" + newUUID()
status, out, _ := e.do(t, "POST", "/api/v1/users", map[string]any{"username": name, "display_name": "Тест", "password": pass}, nil)
if status != 201 {
t.Fatalf("register %s: %d %v", name, status, out)
}
if _, leaked := out["password"]; leaked {
t.Fatal("password must never be returned")
}
return out["id"].(string), pass
}
func (e *env) login(t *testing.T, name, pass string) string {
t.Helper()
status, out, _ := e.do(t, "POST", "/api/v1/auth/sessions", nil, basic(name, pass))
if status != 201 {
t.Fatalf("login: %d %v", status, out)
}
return out["token"].(string)
}
func uname() string { return "t_" + strings.ReplaceAll(newUUID(), "-", "")[:12] }
func TestRegistrationRaceYieldsOneUser(t *testing.T) {
e := setup(t, 3600)
name := uname()
const workers = 16
var wg sync.WaitGroup
codes := make(chan int, workers)
for i := 0; i < workers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
status, _, _ := e.do(t, "POST", "/api/v1/users", map[string]any{"username": name, "display_name": "Гонка", "password": "Race-password-123"}, nil)
codes <- status
}()
}
wg.Wait()
close(codes)
created, conflicts := 0, 0
for c := range codes {
switch c {
case 201:
created++
case 409:
conflicts++
default:
t.Fatalf("unexpected status %d", c)
}
}
if created != 1 || conflicts != workers-1 {
t.Fatalf("expected exactly one 201 and %d×409, got %d / %d", workers-1, created, conflicts)
}
var n int
if err := e.store.pool.QueryRow(context.Background(), `SELECT count(*) FROM users WHERE username = $1`, name).Scan(&n); err != nil || n != 1 {
t.Fatalf("database must hold exactly one row, got %d (%v)", n, err)
}
}
func TestCreateChatIsAtomic(t *testing.T) {
e := setup(t, 3600)
name := uname()
id, pass := e.register(t, name)
ctx := context.Background()
var before int
_ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&before)
// Участник-призрак: INSERT чата уже выполнен, INSERT участников падает на внешнем ключе -> откат всего.
chat := Chat{ID: newUUID(), Title: "rollback", MemberIDs: []string{id, newUUID()}}
if _, err := e.store.createChat(ctx, chat, id); err != errInvalidMembers {
t.Fatalf("expected errInvalidMembers, got %v", err)
}
var after, members int
_ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chats`).Scan(&after)
_ = e.store.pool.QueryRow(ctx, `SELECT count(*) FROM chat_members WHERE chat_id = $1::uuid`, chat.ID).Scan(&members)
if after != before || members != 0 {
t.Fatalf("partial chat left behind: chats %d->%d, members %d", before, after, members)
}
// То же через HTTP: 400, а у пользователя по-прежнему нет чатов.
token := e.login(t, name, pass)
status, _, _ := e.do(t, "POST", "/api/v1/chats", map[string]any{"title": "x", "member_ids": []string{id, newUUID()}}, bearer(token))
if status != 400 {
t.Fatalf("unknown member must give 400, got %d", status)
}
_, list, _ := e.do(t, "GET", "/api/v1/chats", nil, bearer(token))
if items, _ := list["items"].([]any); len(items) != 0 {
t.Fatalf("failed creation must leave no chat, got %d", len(items))
}
}
func TestSessionLifecycle(t *testing.T) {
e := setup(t, 1) // TTL = 1 с
name := uname()
id, pass := e.register(t, name)
// неверный пароль и неизвестный пользователь: одинаковый 401 + Basic challenge
for _, c := range []map[string]string{basic(name, "wrong-password-xx"), basic(uname(), "whatever-password")} {
status, _, h := e.do(t, "POST", "/api/v1/auth/sessions", nil, c)
if status != 401 || h.Get("WWW-Authenticate") != basicChallenge {
t.Fatalf("bad credentials: %d %q", status, h.Get("WWW-Authenticate"))
}
}
token := e.login(t, name, pass)
status, out, _ := e.do(t, "GET", "/api/v1/users/me", nil, bearer(token))
if status != 200 || out["id"] != id {
t.Fatalf("fresh session must work: %d", status)
}
// X-User-Id не даёт доступа и не подменяет владельца; Basic на бизнес-эндпоинте — 401
if status, _, _ := e.do(t, "GET", "/api/v1/users/me", nil, map[string]string{"X-User-Id": id}); status != 401 {
t.Fatalf("X-User-Id alone must give 401, got %d", status)
}
if status, _, h := e.do(t, "GET", "/api/v1/users/me", nil, basic(name, pass)); status != 401 || h.Get("WWW-Authenticate") != bearerChallenge {
t.Fatalf("Basic on business endpoint must give 401 Bearer, got %d", status)
}
// истечение срока
time.Sleep(1300 * time.Millisecond)
if status, _, _ := e.do(t, "GET", "/api/v1/users/me", nil, bearer(token)); status != 401 {
t.Fatalf("expired session must give 401, got %d", status)
}
// logout (отдельный пользователь с длинным TTL)
long := setup(t, 3600)
n2 := uname()
_, p2 := long.register(t, n2)
t2 := long.login(t, n2, p2)
if status, _, _ := long.do(t, "DELETE", "/api/v1/auth/sessions/current", nil, bearer(t2)); status != 204 {
t.Fatalf("logout must give 204, got %d", status)
}
if status, _, _ := long.do(t, "GET", "/api/v1/users/me", nil, bearer(t2)); status != 401 {
t.Fatalf("revoked token must give 401, got %d", status)
}
if status, _, _ := long.do(t, "DELETE", "/api/v1/auth/sessions/current", nil, bearer(t2)); status != 401 {
t.Fatalf("repeated logout must give 401, got %d", status)
}
}
func TestMigrationsAreIdempotent(t *testing.T) {
e := setup(t, 3600)
name := uname()
e.register(t, name)
count := func(table string) int {
var n int
if err := e.store.pool.QueryRow(context.Background(), `SELECT count(*) FROM `+table).Scan(&n); err != nil {
t.Fatal(err)
}
return n
}
users, versions := count("users"), count("schema_migrations")
for i := 0; i < 2; i++ {
if err := runMigrations(context.Background(), e.url); err != nil {
t.Fatal(err)
}
}
if count("users") != users || count("schema_migrations") != versions {
t.Fatal("re-running migrations changed data or duplicated version records")
}
}
+110
View File
@@ -0,0 +1,110 @@
package main
import (
"context"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"net/http"
"regexp"
"strings"
"unicode/utf8"
"github.com/alexedwards/argon2id"
)
// Argon2id (RFC 9106, профиль «низкая память»: t=3, m=64 MiB). Параметры хранятся внутри PHC-строки хеша,
// поэтому их можно менять без инвалидации старых паролей.
var argonParams = &argon2id.Params{Memory: 64 * 1024, Iterations: 3, Parallelism: 2, SaltLength: 16, KeyLength: 32}
var tokenPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{32,256}$`)
// Hasher ограничивает число одновременных хеширований: каждое занимает 64 MiB памяти.
type Hasher struct {
sem chan struct{}
dummy string // хеш-«пустышка»: вход несуществующего пользователя стоит столько же времени, сколько неверный пароль
}
func newHasher(concurrency int) *Hasher {
h := &Hasher{sem: make(chan struct{}, concurrency)}
dummy, err := argon2id.CreateHash("dummy-password-for-timing-equalization", argonParams)
if err != nil {
panic(err)
}
h.dummy = dummy
return h
}
func (h *Hasher) acquire(ctx context.Context) error {
select {
case h.sem <- struct{}{}:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func (h *Hasher) release() { <-h.sem }
func (h *Hasher) hash(ctx context.Context, password string) (string, error) {
if err := h.acquire(ctx); err != nil {
return "", err
}
defer h.release()
return argon2id.CreateHash(password, argonParams)
}
func (h *Hasher) verify(ctx context.Context, password, hash string) (bool, error) {
if err := h.acquire(ctx); err != nil {
return false, err
}
defer h.release()
return argon2id.ComparePasswordAndHash(password, hash) // сравнение за постоянное время
}
// newToken: 32 байта из crypto/rand (256 бит), клиенту — base64url (43 символа), в БД — только SHA-256.
func newToken() (token string, hash []byte) {
raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
panic("crypto/rand failed")
}
token = base64.RawURLEncoding.EncodeToString(raw)
return token, hashToken(token)
}
func hashToken(token string) []byte {
sum := sha256.Sum256([]byte(token))
return sum[:]
}
// splitAuthorization разбирает «Scheme value»; схема нечувствительна к регистру (RFC 9110).
func splitAuthorization(r *http.Request) (scheme, value string) {
header := r.Header.Get("Authorization")
scheme, value, ok := strings.Cut(header, " ")
if !ok {
return "", ""
}
return strings.ToLower(scheme), strings.TrimSpace(value)
}
// parseBasic: base64(username:password), UTF-8. Двоеточие допустимо в пароле, но не в username.
func parseBasic(r *http.Request) (username, password string, ok bool) {
scheme, value := splitAuthorization(r)
if scheme != "basic" || value == "" {
return "", "", false
}
decoded, err := base64.StdEncoding.DecodeString(value)
if err != nil || len(decoded) > 1024 || !utf8.Valid(decoded) {
return "", "", false
}
username, password, ok = strings.Cut(string(decoded), ":")
return username, password, ok
}
// bearerToken возвращает токен только из «Authorization: Bearer …». X-User-Id и Basic игнорируются.
func bearerToken(r *http.Request) (string, bool) {
scheme, value := splitAuthorization(r)
if scheme != "bearer" || !tokenPattern.MatchString(value) {
return "", false
}
return value, true
}
+125
View File
@@ -0,0 +1,125 @@
# Лабораторная 3: Клиент → nginx (LB) → API × N → PostgreSQL (данные + сессии + ключи идемпотентности).
# Запуск: sh scripts/init-secrets.sh (или .ps1) && docker compose up -d --build
# Секреты лежат в ./secrets (создаются scripts/init-secrets.*, в Git не попадают).
name: mtusi-lab3
services:
postgres:
image: postgres:16.9-bookworm
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB:-messenger}
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
command: ["postgres", "-c", "fsync=on", "-c", "synchronous_commit=on", "-c", "full_page_writes=on", "-c", "max_connections=100"]
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
networks:
- backend
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 12
start_period: 10s
stop_grace_period: 30s
deploy:
resources:
limits: { cpus: "1.0", memory: 512m }
# Одноразовая задача: ровно ОДИН процесс применяет миграции (под advisory lock) и завершается.
# Реплики API стартуют только после её успешного завершения и сами миграции не запускают.
migrate:
build: .
image: mtusi-messenger:lab3
command: ["migrate"]
restart: "no"
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
depends_on:
postgres:
condition: service_healthy
networks:
- backend
# Взаимозаменяемые реплики. Без container_name и без published ports: наружу — только через LB.
# Локального состояния нет: сессии, ключи идемпотентности и данные — в PostgreSQL.
api:
build: .
image: mtusi-messenger:lab3
restart: unless-stopped
environment:
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: postgres
DATABASE_URL_FILE: /run/secrets/database_url
DB_MAX_CONNS: ${DB_MAX_CONNS:-10}
SHUTDOWN_DRAIN_SECONDS: ${SHUTDOWN_DRAIN_SECONDS:-1}
secrets:
- database_url
expose:
- "8080"
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
networks:
- lb
- backend
read_only: true
cap_drop:
- ALL
security_opt:
- no-new-privileges:true
stop_grace_period: 15s
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits: { cpus: "0.5", memory: 256m }
# Единственная публичная точка входа. Адреса backend берутся из DNS Docker (имя `api`
# указывает на все живые реплики) и перерезолвятся каждую секунду — см. infra/nginx/default.conf.
lb:
image: nginx:1.27.5-alpine
restart: unless-stopped
ports:
- "127.0.0.1:${PUBLISHED_PORT:-8080}:80"
volumes:
- ./infra/nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
depends_on:
api:
condition: service_healthy
networks:
- lb
- frontend
healthcheck:
test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1/lb-health || exit 1"]
interval: 5s
timeout: 3s
retries: 6
deploy:
resources:
limits: { cpus: "0.5", memory: 128m }
networks:
frontend: {}
lb:
internal: true # LB ↔ API
backend:
internal: true # API ↔ PostgreSQL, наружу выхода нет
volumes:
pgdata: {} # переживает stop/start/restart/up; удаляется только `docker compose down -v`
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
+87
View File
@@ -0,0 +1,87 @@
package main
import (
"fmt"
"os"
"strconv"
"strings"
"time"
)
// Config собирается только из переменных окружения (см. .env.example).
// Секреты (строка подключения к БД) читаются из файла, а не из env.
type Config struct {
Host string
Port string
SessionTTLSecs int
SessionStore string
DatabaseURL string
DBMaxConns int32
DrainPeriod time.Duration
}
func envOr(name, fallback string) string {
if v := os.Getenv(name); v != "" {
return v
}
return fallback
}
func envInt(name string, fallback, min, max int) (int, error) {
raw := os.Getenv(name)
if raw == "" {
return fallback, nil
}
n, err := strconv.Atoi(raw)
if err != nil || n < min || n > max {
return 0, fmt.Errorf("%s must be an integer in [%d, %d]", name, min, max)
}
return n, nil
}
// readSecretFile читает секрет из файла (Docker secrets); BOM и перевод строки отбрасываются,
// чтобы файл, созданный в Windows PowerShell, работал так же, как созданный в Linux.
func readSecretFile(path string) (string, error) {
raw, err := os.ReadFile(path)
if err != nil {
return "", err
}
return strings.TrimSpace(strings.TrimPrefix(string(raw), "\xEF\xBB\xBF")), nil
}
func loadConfig() (Config, error) {
cfg := Config{Host: envOr("APP_HOST", "0.0.0.0"), Port: envOr("APP_PORT", "8080")}
if _, err := strconv.Atoi(cfg.Port); err != nil {
return cfg, fmt.Errorf("APP_PORT must be an integer")
}
ttl, err := envInt("SESSION_TTL_SECONDS", 3600, 1, 30*24*3600)
if err != nil {
return cfg, err
}
cfg.SessionTTLSecs = ttl
conns, err := envInt("DB_MAX_CONNS", 10, 1, 100)
if err != nil {
return cfg, err
}
cfg.DBMaxConns = int32(conns)
drain, err := envInt("SHUTDOWN_DRAIN_SECONDS", 1, 0, 30)
if err != nil {
return cfg, err
}
cfg.DrainPeriod = time.Duration(drain) * time.Second
cfg.SessionStore = envOr("SESSION_STORE", "postgres")
if cfg.SessionStore != "postgres" {
return cfg, fmt.Errorf("SESSION_STORE=%q is not supported at grade 3 (only \"postgres\")", cfg.SessionStore)
}
if file := os.Getenv("DATABASE_URL_FILE"); file != "" {
if cfg.DatabaseURL, err = readSecretFile(file); err != nil {
return cfg, fmt.Errorf("cannot read DATABASE_URL_FILE: %w", err)
}
} else {
cfg.DatabaseURL = os.Getenv("DATABASE_URL") // только для локальной отладки без Docker secrets
}
if cfg.DatabaseURL == "" {
return cfg, fmt.Errorf("set DATABASE_URL_FILE (path to a file with the PostgreSQL URL)")
}
return cfg, nil
}
+18
View File
@@ -0,0 +1,18 @@
module mtusi-messenger
go 1.23
require (
github.com/alexedwards/argon2id v1.0.0
github.com/jackc/pgx/v5 v5.7.2
)
require (
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
golang.org/x/crypto v0.31.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
)
+70
View File
@@ -0,0 +1,70 @@
github.com/alexedwards/argon2id v1.0.0 h1:wJzDx66hqWX7siL/SRUmgz3F8YMrd/nfX/xHHcQQP0w=
github.com/alexedwards/argon2id v1.0.0/go.mod h1:tYKkqIjzXvZdzPvADMWOEZ+l6+BD6CtBXMj5fnJppiw=
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/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.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI=
github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
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/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
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.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
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/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
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=
+405
View File
@@ -0,0 +1,405 @@
package main
import (
"context"
"crypto/sha256"
"sync/atomic"
"errors"
"log"
"net/http"
"runtime/debug"
"sort"
"strings"
"time"
"unicode/utf8"
)
type API struct {
store *Store
hasher *Hasher
ttlSecs int
reqLimit time.Duration
// instanceID — стабильный на всё время жизни процесса псевдоним реплики (X-Instance-Id).
instanceID string
// draining выставляется по SIGTERM: /health/ready отвечает 503, новые запросы уходят на другие реплики.
draining atomic.Bool
}
// ---- аутентификация ----
// actor: «кто вы». Только действующая Bearer-сессия из PostgreSQL; ответ на любой сбой одинаков.
func (a *API) actor(r *http.Request) (User, string, *apiError) {
token, ok := bearerToken(r)
if !ok {
return User{}, "", unauthorized(bearerChallenge, "Требуется Authorization: Bearer <token>")
}
user, err := a.store.sessionUser(r.Context(), hashToken(token))
if errors.Is(err, errNotFound) {
return User{}, "", unauthorized(bearerChallenge, "Недействительная сессия")
}
if err != nil {
return User{}, "", dbFail(err)
}
return user, token, nil
}
func (a *API) createSession(r *http.Request) (int, any, *apiError) {
denied := unauthorized(basicChallenge, "Неверные учётные данные")
username, password, ok := parseBasic(r)
if !ok {
return 0, nil, denied
}
user, hash, err := a.store.userWithHash(r.Context(), username)
found := err == nil
if err != nil && !errors.Is(err, errNotFound) {
return 0, nil, dbFail(err)
}
if !found {
hash = a.hasher.dummy
}
match, herr := a.hasher.verify(r.Context(), password, hash)
if herr != nil && !errors.Is(herr, context.Canceled) && !errors.Is(herr, context.DeadlineExceeded) {
match = false // повреждённый хеш = отказ, не 500
} else if herr != nil {
return 0, nil, unavailable()
}
if !found || !match {
return 0, nil, denied
}
token, tokenHash := newToken()
expires, err := a.store.createSession(r.Context(), tokenHash, user.ID, a.ttlSecs)
if err != nil {
return 0, nil, dbFail(err)
}
return http.StatusCreated, map[string]any{
"token": token, "token_type": "Bearer", "expires_at": formatTime(expires), "user": user,
}, nil
}
func (a *API) revokeSession(r *http.Request) (int, any, *apiError) {
_, token, err := a.actor(r)
if err != nil {
return 0, nil, err
}
if rerr := a.store.revokeSession(r.Context(), hashToken(token)); rerr != nil {
return 0, nil, dbFail(rerr)
}
return http.StatusNoContent, nil, nil
}
// ---- пользователи ----
func (a *API) createUser(r *http.Request) (int, any, *apiError) {
body, err := readJSON(r)
if err != nil {
return 0, nil, err
}
if err := exactFields(body, "username", "display_name", "password"); err != nil {
return 0, nil, err
}
username, ok := body["username"].(string)
if !ok || !usernamePattern.MatchString(username) {
return 0, nil, invalid("Некорректный username")
}
displayName, err := requiredString(body["display_name"], 100, "display_name")
if err != nil {
return 0, nil, err
}
password, ok := body["password"].(string)
if n := utf8.RuneCountInString(password); !ok || !utf8.ValidString(password) || n < 12 || n > 128 {
return 0, nil, invalid("Некорректный password")
}
hash, herr := a.hasher.hash(r.Context(), password)
if herr != nil {
return 0, nil, unavailable()
}
user, serr := a.store.createUser(r.Context(), User{ID: newUUID(), Username: username, DisplayName: displayName}, hash)
if errors.Is(serr, errConflict) {
return 0, nil, fail(http.StatusConflict, "conflict", "Username уже занят")
}
if serr != nil {
return 0, nil, dbFail(serr)
}
return http.StatusCreated, user, nil
}
func (a *API) currentUser(r *http.Request) (int, any, *apiError) {
user, _, err := a.actor(r)
if err != nil {
return 0, nil, err
}
return http.StatusOK, user, nil
}
// ---- чаты ----
func (a *API) createChat(r *http.Request) (int, any, *apiError) {
actor, _, err := a.actor(r)
if err != nil {
return 0, nil, err
}
body, err := readJSON(r)
if err != nil {
return 0, nil, err
}
if err := exactFields(body, "title", "member_ids"); err != nil {
return 0, nil, err
}
title, err := requiredString(body["title"], 100, "title")
if err != nil {
return 0, nil, err
}
rawMembers, ok := body["member_ids"].([]any)
if !ok || len(rawMembers) < 1 || len(rawMembers) > 100 {
return 0, nil, invalid("Некорректные участники")
}
members, seen := make([]string, 0, len(rawMembers)), map[string]bool{}
for _, raw := range rawMembers {
member, typeOK := raw.(string)
id, idOK := validUUID(member)
if !typeOK || !idOK || seen[id] {
return 0, nil, invalid("Некорректные участники")
}
seen[id] = true
members = append(members, id)
}
if !seen[actor.ID] {
return 0, nil, invalid("Создатель должен быть участником")
}
sort.Strings(members) // детерминированный порядок: одинаковый в POST и GET
chat, serr := a.store.createChat(r.Context(), Chat{ID: newUUID(), Title: title, MemberIDs: members}, actor.ID)
if errors.Is(serr, errInvalidMembers) {
return 0, nil, invalid("Некорректные участники")
}
if serr != nil {
return 0, nil, dbFail(serr)
}
return http.StatusCreated, chat, nil
}
func (a *API) listChats(r *http.Request) (int, any, *apiError) {
actor, _, err := a.actor(r)
if err != nil {
return 0, nil, err
}
limit, rawCursor, err := parsePage(r)
if err != nil {
return 0, nil, err
}
var after *time.Time
var afterID string
if rawCursor != "" {
t, id, cerr := decodeCursor(rawCursor, "chats", actor.ID)
if cerr != nil {
return 0, nil, cerr
}
after, afterID = &t, id
}
items, next, serr := a.store.listChats(r.Context(), actor.ID, limit, after, afterID)
if serr != nil {
return 0, nil, dbFail(serr)
}
return http.StatusOK, pageBody(items, next), nil
}
func pageBody(items any, next string) map[string]any {
var cursor any
if next != "" {
cursor = next
}
return map[string]any{"items": items, "next_cursor": cursor}
}
// chatAccess: сначала аутентификация (вызывается до этого), затем доступ к конкретному чату.
// Чужой и несуществующий чат неразличимы: оба дают 404.
func (a *API) chatAccess(r *http.Request, actorID, rawID string) (string, *apiError) {
id, ok := validUUID(rawID)
if !ok {
return "", invalid("Некорректный идентификатор")
}
member, err := a.store.isMember(r.Context(), actorID, id)
if err != nil {
return "", dbFail(err)
}
if !member {
return "", notFound()
}
return id, nil
}
func (a *API) getChat(r *http.Request, rawID string) (int, any, *apiError) {
actor, _, err := a.actor(r)
if err != nil {
return 0, nil, err
}
id, ok := validUUID(rawID)
if !ok {
return 0, nil, invalid("Некорректный идентификатор")
}
chat, serr := a.store.getChat(r.Context(), actor.ID, id)
if errors.Is(serr, errNotFound) {
return 0, nil, notFound()
}
if serr != nil {
return 0, nil, dbFail(serr)
}
return http.StatusOK, chat, nil
}
// ---- сообщения ----
func (a *API) createMessage(r *http.Request, rawID string) (int, any, *apiError) {
actor, _, err := a.actor(r)
if err != nil {
return 0, nil, err
}
chatID, err := a.chatAccess(r, actor.ID, rawID)
if err != nil {
return 0, nil, err
}
keys := r.Header.Values("Idempotency-Key")
if len(keys) != 1 || !idempotencyKeyPattern.MatchString(keys[0]) {
return 0, nil, invalid("Требуется корректный заголовок Idempotency-Key")
}
key := keys[0]
body, err := readJSON(r)
if err != nil {
return 0, nil, err
}
// sender_id в теле не принимается: лишнее поле — 400. Отправитель берётся только из сессии.
if err := exactFields(body, "text"); err != nil {
return 0, nil, err
}
text, err := requiredString(body["text"], 4000, "text")
if err != nil {
return 0, nil, err
}
sum := sha256.Sum256([]byte(text)) // канонический вид тела: единственное поле text
path := "/api/v1/chats/" + chatID + "/messages"
message, _, serr := a.store.createMessageIdempotent(r.Context(),
Message{ID: newUUID(), ChatID: chatID, SenderID: actor.ID, Text: text}, key, path, sum[:])
if errors.Is(serr, errConflict) {
return 0, nil, fail(http.StatusConflict, "conflict", "Idempotency-Key уже использован с другим сообщением")
}
if serr != nil {
return 0, nil, dbFail(serr)
}
return http.StatusCreated, message, nil
}
func (a *API) listMessages(r *http.Request, rawID string) (int, any, *apiError) {
actor, _, err := a.actor(r)
if err != nil {
return 0, nil, err
}
chatID, err := a.chatAccess(r, actor.ID, rawID)
if err != nil {
return 0, nil, err
}
limit, rawCursor, err := parsePage(r)
if err != nil {
return 0, nil, err
}
var after *time.Time
var afterID string
if rawCursor != "" {
t, id, cerr := decodeCursor(rawCursor, "messages", chatID)
if cerr != nil {
return 0, nil, cerr
}
after, afterID = &t, id
}
items, next, serr := a.store.listMessages(r.Context(), chatID, limit, after, afterID)
if serr != nil {
return 0, nil, dbFail(serr)
}
return http.StatusOK, pageBody(items, next), nil
}
// ---- health ----
func (a *API) ready(r *http.Request) (int, any, *apiError) {
if a.draining.Load() {
return 0, nil, unavailable()
}
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
defer cancel()
if err := a.store.ready(ctx); err != nil {
log.Printf("readiness: dependency check failed")
return 0, nil, unavailable()
}
return http.StatusOK, map[string]string{"status": "ok"}, nil
}
// ---- маршрутизация ----
func (a *API) dispatch(r *http.Request) (int, any, *apiError) {
path := r.URL.Path
switch {
case r.Method == http.MethodGet && path == "/health/live":
return http.StatusOK, map[string]string{"status": "ok"}, nil
case r.Method == http.MethodGet && path == "/health/ready":
return a.ready(r)
case r.Method == http.MethodPost && path == "/api/v1/users":
return a.createUser(r)
case r.Method == http.MethodGet && path == "/api/v1/users/me":
return a.currentUser(r)
case r.Method == http.MethodPost && path == "/api/v1/auth/sessions":
return a.createSession(r) // единственное место, где принимается Basic
case r.Method == http.MethodDelete && path == "/api/v1/auth/sessions/current":
return a.revokeSession(r)
case r.Method == http.MethodPost && path == "/api/v1/chats":
return a.createChat(r)
case r.Method == http.MethodGet && path == "/api/v1/chats":
return a.listChats(r)
}
parts := strings.Split(strings.Trim(path, "/"), "/")
if len(parts) == 4 && strings.Join(parts[:3], "/") == "api/v1/chats" && r.Method == http.MethodGet {
return a.getChat(r, parts[3])
}
if len(parts) == 5 && strings.Join(parts[:3], "/") == "api/v1/chats" && parts[4] == "messages" {
if r.Method == http.MethodPost {
return a.createMessage(r, parts[3])
}
if r.Method == http.MethodGet {
return a.listMessages(r, parts[3])
}
}
return 0, nil, notFound()
}
type statusWriter struct {
http.ResponseWriter
status int
}
func (w *statusWriter) WriteHeader(code int) { w.status = code; w.ResponseWriter.WriteHeader(code) }
func (a *API) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
id := newUUID()
rw.Header().Set("X-Instance-Id", a.instanceID)
w := &statusWriter{ResponseWriter: rw, status: 200}
started := time.Now()
ctx, cancel := context.WithTimeout(r.Context(), a.reqLimit)
defer cancel()
r = r.WithContext(ctx)
defer func() {
if rec := recover(); rec != nil {
log.Printf("panic request_id=%s: %v\n%s", id, rec, debug.Stack())
writeError(w, id, fail(http.StatusInternalServerError, "internal_error", "Внутренняя ошибка"))
}
// В лог не попадают заголовки, query-строка, тела запросов и токены.
log.Printf("%s %s -> %d request_id=%s %s", r.Method, r.URL.Path, w.status, id, time.Since(started).Round(time.Millisecond))
}()
status, body, err := a.dispatch(r)
if err != nil {
writeError(w, id, err)
return
}
if status == http.StatusNoContent {
w.Header().Set("X-Request-Id", id)
w.WriteHeader(status)
return
}
writeJSON(w, id, status, body)
}
+204
View File
@@ -0,0 +1,204 @@
package main
import (
"crypto/rand"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"mime"
"net/http"
"regexp"
"strconv"
"strings"
"time"
"unicode/utf8"
)
const maxJSONBytes = 1 << 20
var (
usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
uuidPattern = 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}$`)
)
type apiError struct {
status int
code, message string
challenge string // значение WWW-Authenticate для 401
}
func fail(status int, code, message string) *apiError {
return &apiError{status: status, code: code, message: message}
}
func invalid(message string) *apiError {
return fail(http.StatusBadRequest, "invalid_request", message)
}
func notFound() *apiError {
return fail(http.StatusNotFound, "not_found", "Объект не найден")
}
func unavailable() *apiError {
return fail(http.StatusServiceUnavailable, "unavailable", "Сервис временно недоступен")
}
func unauthorized(challenge, message string) *apiError {
e := fail(http.StatusUnauthorized, "unauthorized", message)
e.challenge = challenge
return e
}
const (
bearerChallenge = `Bearer realm="messenger"`
basicChallenge = `Basic realm="messenger", charset="UTF-8"`
)
func newUUID() string {
b := make([]byte, 16)
if _, err := rand.Read(b); err != nil {
panic("crypto/rand failed")
}
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])
}
// formatTime — RFC 3339 UTC, всегда 6 знаков долей секунды (точность PostgreSQL).
func formatTime(t time.Time) string { return t.UTC().Format("2006-01-02T15:04:05.000000Z") }
func validUUID(value string) (string, bool) {
if !uuidPattern.MatchString(value) {
return "", false
}
return strings.ToLower(value), true
}
// cleanText: валидный UTF-8 без NUL (PostgreSQL не хранит \x00 в text).
func cleanText(s string) bool { return utf8.ValidString(s) && !strings.ContainsRune(s, 0) }
func requiredString(value any, limit int, field string) (string, *apiError) {
text, ok := value.(string)
if !ok || text == "" || strings.TrimSpace(text) == "" || !cleanText(text) || utf8.RuneCountInString(text) > limit {
return "", invalid("Некорректное поле " + field)
}
return text, nil
}
func exactFields(body map[string]any, expected ...string) *apiError {
if len(body) != len(expected) {
return invalid("Неожиданные или отсутствующие поля")
}
for _, name := range expected {
if _, ok := body[name]; !ok {
return invalid("Неожиданные или отсутствующие поля")
}
}
return nil
}
func readJSON(r *http.Request) (map[string]any, *apiError) {
mediaType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil || mediaType != "application/json" {
return nil, fail(http.StatusUnsupportedMediaType, "unsupported_media_type", "Требуется application/json")
}
raw, err := io.ReadAll(io.LimitReader(r.Body, maxJSONBytes+1))
if err != nil {
return nil, invalid("Некорректное тело запроса")
}
if len(raw) > maxJSONBytes {
return nil, fail(http.StatusRequestEntityTooLarge, "payload_too_large", "Слишком большой JSON")
}
if !utf8.Valid(raw) {
return nil, invalid("Некорректный JSON")
}
decoder := json.NewDecoder(strings.NewReader(string(raw)))
var body map[string]any
if err := decoder.Decode(&body); err != nil || body == nil {
return nil, invalid("Некорректный JSON")
}
var trailing any
if err := decoder.Decode(&trailing); err != io.EOF {
return nil, invalid("Некорректный JSON")
}
return body, nil
}
func writeJSON(w http.ResponseWriter, id string, status int, body any) {
w.Header().Set("X-Request-Id", id)
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.WriteHeader(status)
enc := json.NewEncoder(w)
enc.SetEscapeHTML(false)
_ = enc.Encode(body)
}
func writeError(w http.ResponseWriter, id string, err *apiError) {
if err.challenge != "" {
w.Header().Set("WWW-Authenticate", err.challenge)
}
writeJSON(w, id, err.status, map[string]any{"error": map[string]string{"code": err.code, "message": err.message, "request_id": id}})
}
func parsePage(r *http.Request) (int, string, *apiError) {
query := r.URL.Query()
if len(query["limit"]) > 1 || len(query["cursor"]) > 1 {
return 0, "", invalid("Повторяющийся параметр пагинации")
}
limit := 50
if values, exists := query["limit"]; exists {
n, err := strconv.Atoi(values[0])
if err != nil || n < 1 || n > 100 || strconv.Itoa(n) != values[0] {
return 0, "", invalid("Некорректный limit")
}
limit = n
}
if values, exists := query["cursor"]; exists {
if values[0] == "" {
return 0, "", invalid("Некорректный cursor")
}
return limit, values[0], nil
}
return limit, "", nil
}
// cursor — непрозрачная для клиента строка: ключ (created_at, id) + тип списка + владелец
// (id чата либо пользователя). Курсор другого ресурса отклоняется с 400.
type cursor struct {
Kind string `json:"k"`
Owner string `json:"o"`
Time string `json:"t"`
ID string `json:"i"`
}
func encodeCursor(kind, owner string, created time.Time, id string) string {
raw, _ := json.Marshal(cursor{kind, owner, formatTime(created), id})
return base64.RawURLEncoding.EncodeToString(raw)
}
func decodeCursor(value, kind, owner string) (time.Time, string, *apiError) {
raw, err := base64.RawURLEncoding.DecodeString(value)
if err != nil {
return time.Time{}, "", invalid("Некорректный cursor")
}
var fields map[string]any
if json.Unmarshal(raw, &fields) != nil || len(fields) != 4 {
return time.Time{}, "", invalid("Некорректный cursor")
}
for _, name := range []string{"k", "o", "t", "i"} {
if _, ok := fields[name].(string); !ok {
return time.Time{}, "", invalid("Некорректный cursor")
}
}
c := cursor{fields["k"].(string), fields["o"].(string), fields["t"].(string), fields["i"].(string)}
if c.Kind != kind || c.Owner != owner {
return time.Time{}, "", invalid("Некорректный cursor")
}
id, ok := validUUID(c.ID)
if !ok {
return time.Time{}, "", invalid("Некорректный cursor")
}
t, err := time.Parse("2006-01-02T15:04:05.000000Z", c.Time)
if err != nil {
return time.Time{}, "", invalid("Некорректный cursor")
}
return t, id, nil
}
+36
View File
@@ -0,0 +1,36 @@
# LB без sticky session: каждый запрос независимо уходит на любую живую реплику.
# Docker DNS отдаёт имя `api` → IP всех работающих реплик (в случайном порядке);
# resolver с valid=1s заставляет nginx обновлять список backend каждую секунду,
# поэтому остановленная реплика исчезает из ротации максимум за ~1-2 с.
resolver 127.0.0.11 valid=1s ipv6=off;
server {
listen 80;
server_name _;
# Проверка самого LB (healthcheck контейнера).
location = /lb-health {
access_log off;
default_type text/plain;
return 200 "ok\n";
}
location / {
set $api_upstream http://api:8080;
proxy_pass $api_upstream;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $remote_addr;
# Отказ реплики: быстрый connect-timeout и повтор на другом адресе.
# Повторяются только ошибки соединения/таймаут/502/503/504; POST после отправки тела
# автоматически НЕ повторяется (без non_idempotent) — безопасный повтор делает клиент
# с тем же Idempotency-Key.
proxy_connect_timeout 1s;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 3;
proxy_next_upstream_timeout 5s;
}
}
+116
View File
@@ -0,0 +1,116 @@
package main
import (
"context"
"errors"
"fmt"
"log"
"net"
"net/http"
"os"
"os/signal"
"syscall"
"time"
)
func main() {
command := "serve"
if len(os.Args) > 1 {
command = os.Args[1]
}
switch command {
case "serve":
os.Exit(serve())
case "migrate":
os.Exit(migrateCommand())
case "healthcheck":
os.Exit(healthcheck())
default:
fmt.Fprintln(os.Stderr, "usage: messenger [serve|migrate|healthcheck]")
os.Exit(2)
}
}
func migrateCommand() int {
cfg, err := loadConfig()
if err != nil {
log.Printf("config error: %v", err)
return 1
}
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
if err := runMigrations(ctx, cfg.DatabaseURL); err != nil {
log.Printf("migrate failed: %v", err)
return 1
}
return 0
}
// healthcheck нужен для HEALTHCHECK контейнера: в образе scratch нет ни shell, ни curl.
func healthcheck() int {
client := &http.Client{Timeout: 3 * time.Second}
resp, err := client.Get("http://127.0.0.1:" + envOr("APP_PORT", "8080") + "/health/ready")
if err != nil {
return 1
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return 1
}
return 0
}
func serve() int {
cfg, err := loadConfig()
if err != nil {
log.Printf("config error: %v", err)
return 1
}
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
pool, err := newPool(ctx, cfg.DatabaseURL, cfg.DBMaxConns)
if err != nil {
log.Printf("database setup error: %v", err)
return 1
}
defer pool.Close()
// Псевдоним реплики = hostname контейнера (короткий ID): по нему stop-one находит контейнер.
instance, _ := os.Hostname()
if instance == "" {
instance = newUUID()
}
api := &API{store: &Store{pool: pool}, hasher: newHasher(4), ttlSecs: cfg.SessionTTLSecs, reqLimit: 8 * time.Second, instanceID: instance}
server := &http.Server{
Addr: net.JoinHostPort(cfg.Host, cfg.Port),
Handler: api,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 15 * time.Second,
WriteTimeout: 30 * time.Second,
IdleTimeout: 60 * time.Second,
}
errs := make(chan error, 1)
go func() { errs <- server.ListenAndServe() }()
log.Printf("messenger listening on %s (instance %s, session ttl %ds, max db conns %d)", server.Addr, instance, cfg.SessionTTLSecs, cfg.DBMaxConns)
select {
case err := <-errs:
if !errors.Is(err, http.ErrServerClosed) {
log.Printf("server error: %v", err)
return 1
}
case <-ctx.Done():
// Сначала перестаём быть «готовыми», даём LB время убрать реплику, и только затем закрываем listener.
api.draining.Store(true)
log.Printf("shutting down: not ready, draining %s, then finishing in-flight requests", cfg.DrainPeriod)
time.Sleep(cfg.DrainPeriod)
shutdown, cancel := context.WithTimeout(context.Background(), 8*time.Second)
defer cancel()
if err := server.Shutdown(shutdown); err != nil {
log.Printf("shutdown error: %v", err)
return 1
}
}
return 0
}
+122
View File
@@ -0,0 +1,122 @@
package main
import (
"context"
"crypto/sha256"
"embed"
"encoding/hex"
"fmt"
"log"
"sort"
"strconv"
"strings"
"time"
"github.com/jackc/pgx/v5"
)
//go:embed migrations/*.sql
var migrationFS embed.FS
// Произвольная константа-ключ advisory lock: параллельные запуски миграций выстраиваются в очередь.
const migrationLockKey int64 = 7_272_026_002
type migration struct{ version, sql, checksum string }
func itoa(n int) string { return strconv.Itoa(n) }
func loadMigrations() []migration {
entries, err := migrationFS.ReadDir("migrations")
if err != nil {
panic(err)
}
var list []migration
for _, e := range entries {
if e.IsDir() || !strings.HasSuffix(e.Name(), ".sql") {
continue
}
raw, err := migrationFS.ReadFile("migrations/" + e.Name())
if err != nil {
panic(err)
}
sum := sha256.Sum256(raw)
list = append(list, migration{strings.TrimSuffix(e.Name(), ".sql"), string(raw), hex.EncodeToString(sum[:])})
}
sort.Slice(list, func(i, j int) bool { return list[i].version < list[j].version })
return list
}
func migrationVersions() []string {
var v []string
for _, m := range loadMigrations() {
v = append(v, m.version)
}
return v
}
// runMigrations применяет только ещё не применённые версии. Повторный запуск ничего не меняет и не трогает данные:
// каждая версия записывается в schema_migrations в той же транзакции, что и сама миграция.
func runMigrations(ctx context.Context, databaseURL string) error {
var conn *pgx.Conn
var err error
deadline := time.Now().Add(60 * time.Second)
for {
cctx, cancel := context.WithTimeout(ctx, 5*time.Second)
conn, err = pgx.Connect(cctx, databaseURL)
cancel()
if err == nil {
break
}
if time.Now().After(deadline) || ctx.Err() != nil {
return fmt.Errorf("database is not reachable: %w", err)
}
log.Printf("migrate: waiting for database...")
time.Sleep(2 * time.Second)
}
defer conn.Close(context.Background())
if _, err := conn.Exec(ctx, `SELECT pg_advisory_lock($1)`, migrationLockKey); err != nil {
return err
}
defer func() { _, _ = conn.Exec(context.Background(), `SELECT pg_advisory_unlock($1)`, migrationLockKey) }()
if _, err := conn.Exec(ctx, `CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
checksum text NOT NULL,
applied_at timestamptz NOT NULL DEFAULT now())`); err != nil {
return err
}
applied := 0
for _, m := range loadMigrations() {
var have string
err := conn.QueryRow(ctx, `SELECT checksum FROM schema_migrations WHERE version = $1`, m.version).Scan(&have)
if err == nil {
if have != m.checksum {
return fmt.Errorf("migration %s was changed after being applied (checksum mismatch)", m.version)
}
continue
}
if err != pgx.ErrNoRows {
return err
}
tx, err := conn.Begin(ctx)
if err != nil {
return err
}
if _, err := tx.Exec(ctx, m.sql); err != nil {
_ = tx.Rollback(ctx)
return fmt.Errorf("migration %s failed: %w", m.version, err)
}
if _, err := tx.Exec(ctx, `INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)`, m.version, m.checksum); err != nil {
_ = tx.Rollback(ctx)
return err
}
if err := tx.Commit(ctx); err != nil {
return err
}
applied++
log.Printf("migrate: applied %s", m.version)
}
log.Printf("migrate: done, %d new, %d total", applied, len(loadMigrations()))
return nil
}
+45
View File
@@ -0,0 +1,45 @@
-- Источник истины: пользователи, чаты, участники и сообщения.
-- Транзакционные границы:
-- * регистрация — один INSERT в users (уникальность username решает сама БД);
-- * создание чата — INSERT в chats + INSERT всех участников в одной транзакции;
-- * отправка сообщения — один INSERT в messages (id и время назначает сервер).
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 clock_timestamp(),
CONSTRAINT users_username_key UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_by uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
-- Список чатов отсортирован по (created_at, id) — keyset-пагинация без OFFSET.
CREATE INDEX chats_created_at_id_idx ON chats (created_at, id);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
PRIMARY KEY (chat_id, user_id)
);
-- «Чаты пользователя»: поиск по user_id, а не по chat_id.
CREATE INDEX chat_members_user_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),
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
);
-- История чата: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n.
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
+15
View File
@@ -0,0 +1,15 @@
-- Серверные сессии. Клиент получает непрозрачный токен (256 бит случайности),
-- в БД хранится только его SHA-256: утечка таблицы не раскрывает рабочие токены.
-- Срок жизни абсолютный (expires_at) и не продлевается рестартом.
CREATE TABLE sessions (
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,
CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32),
CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at)
);
CREATE INDEX sessions_expires_at_idx ON sessions (expires_at);
CREATE INDEX sessions_user_idx ON sessions (user_id);
+19
View File
@@ -0,0 +1,19 @@
-- Общая (между репликами API) идемпотентность отправки сообщения.
-- Область уникальности: пользователь + HTTP-метод + путь чата + ключ.
-- Запись ключа и сообщение создаются в ОДНОЙ транзакции, поэтому «побочный эффект» и
-- «результат» атомарны, а конкурентный повтор на другой реплике блокируется уникальным
-- индексом до коммита первой транзакции и затем видит готовый результат.
CREATE TABLE idempotency_keys (
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
method text NOT NULL,
path text NOT NULL,
key text NOT NULL,
request_hash bytea NOT NULL,
message_id uuid REFERENCES messages (id) ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, method, path, key),
CONSTRAINT idempotency_key_format CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$')
);
-- Очистка ключей старше 24 часов.
CREATE INDEX idempotency_keys_created_idx ON idempotency_keys (created_at);
+25
View File
@@ -0,0 +1,25 @@
# Creates local secrets and .env (Windows PowerShell 5.1 / PowerShell 7).
# Existing files are NEVER overwritten: the password of an already initialised database volume
# must keep matching secrets/postgres_password.
$ErrorActionPreference = 'Stop'
Set-Location (Join-Path $PSScriptRoot '..')
$db = if ($env:POSTGRES_DB) { $env:POSTGRES_DB } else { 'messenger' }
$user = if ($env:POSTGRES_USER) { $env:POSTGRES_USER } else { 'messenger' }
New-Item -ItemType Directory -Force -Path 'secrets' | Out-Null
# UTF-8 WITHOUT BOM and without a trailing newline: readable by the PostgreSQL image and by the app.
$utf8 = New-Object System.Text.UTF8Encoding($false)
$pwFile = Join-Path (Get-Location) 'secrets/postgres_password'
$urlFile = Join-Path (Get-Location) 'secrets/database_url'
if (-not (Test-Path $pwFile)) {
$bytes = New-Object byte[] 24
[System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
$password = ($bytes | ForEach-Object { $_.ToString('x2') }) -join ''
[System.IO.File]::WriteAllText($pwFile, $password, $utf8)
Write-Host 'created secrets/postgres_password'
}
if (-not (Test-Path $urlFile)) {
$password = [System.IO.File]::ReadAllText($pwFile).Trim()
[System.IO.File]::WriteAllText($urlFile, "postgres://${user}:${password}@postgres:5432/${db}?sslmode=disable", $utf8)
Write-Host 'created secrets/database_url'
}
if (-not (Test-Path '.env')) { Copy-Item '.env.example' '.env'; Write-Host 'created .env' }
+20
View File
@@ -0,0 +1,20 @@
#!/bin/sh
# Создаёт локальные секреты и .env (Linux/macOS/Git Bash). Существующие файлы НЕ перезаписываются:
# пароль уже созданной БД в volume должен совпадать с secrets/postgres_password.
set -eu
cd "$(dirname "$0")/.."
DB="${POSTGRES_DB:-messenger}"
USER_NAME="${POSTGRES_USER:-messenger}"
mkdir -p secrets
if [ ! -f secrets/postgres_password ]; then
head -c 24 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/postgres_password
echo "created secrets/postgres_password" >&2
fi
if [ ! -f secrets/database_url ]; then
printf 'postgres://%s:%s@postgres:5432/%s?sslmode=disable' "$USER_NAME" "$(cat secrets/postgres_password)" "$DB" > secrets/database_url
echo "created secrets/database_url" >&2
fi
# Контейнеры работают не от вашего пользователя: файлы должны читаться всеми (каталог в Git не попадает).
chmod 755 secrets
chmod 644 secrets/postgres_password secrets/database_url
if [ ! -f .env ]; then cp .env.example .env; echo "created .env" >&2; fi
+25
View File
@@ -0,0 +1,25 @@
@echo off
rem Full restart of LB, all API replicas and PostgreSQL, volumes are preserved (Windows). No secrets are printed.
setlocal
cd /d "%~dp0.." || exit /b 1
docker compose stop lb api postgres >nul 2>&1
if errorlevel 1 exit /b 1
docker compose start postgres >nul 2>&1
if errorlevel 1 exit /b 1
set /a tries=0
:waitpg
docker compose exec -T postgres sh -c "pg_isready -q -U $POSTGRES_USER -d $POSTGRES_DB" >nul 2>&1
if not errorlevel 1 goto pgready
set /a tries+=1
if %tries% GEQ 45 exit /b 1
rem ping instead of timeout: timeout fails when stdin is redirected (as in tests/resilience.py)
ping -n 2 127.0.0.1 >nul
goto waitpg
:pgready
docker compose start api >nul 2>&1
if errorlevel 1 exit /b 1
docker compose start lb >nul 2>&1
exit /b %errorlevel%
+23
View File
@@ -0,0 +1,23 @@
#!/bin/sh
# Полный перезапуск LB, ВСЕХ реплик API и используемых хранилищ (PostgreSQL) с сохранением volumes.
# Не использует down -v / удаление volumes / повторный seed. Вывод секретов отсутствует.
set -eu
cd "$(dirname "$0")/.."
# stop → SIGTERM (graceful): API дожидается запросов, PostgreSQL делает fast shutdown и сбрасывает WAL.
docker compose stop lb api postgres >/dev/null 2>&1
docker compose start postgres >/dev/null 2>&1
tries=0
until docker compose exec -T postgres sh -c 'pg_isready -q -U "$POSTGRES_USER" -d "$POSTGRES_DB"' >/dev/null 2>&1; do
tries=$((tries + 1))
if [ "$tries" -ge 45 ]; then
echo "postgres did not become ready in time" >&2
exit 1
fi
sleep 1
done
docker compose start api >/dev/null 2>&1
docker compose start lb >/dev/null 2>&1
exit 0
+3
View File
@@ -0,0 +1,3 @@
@echo off
cd /d "%~dp0.." || exit /b 1
docker compose up -d
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
# Восстановление: поднимает все остановленные/недостающие сервисы (в т.ч. остановленную реплику API).
set -eu
cd "$(dirname "$0")/.."
docker compose up -d
+11
View File
@@ -0,0 +1,11 @@
@echo off
rem Stops exactly ONE API replica: the container whose hostname equals TARGET_INSTANCE_ID (X-Instance-Id).
rem Leaves it stopped; DB, LB and volumes are untouched. Restore separately: docker compose up -d
setlocal
if "%TARGET_INSTANCE_ID%"=="" exit /b 2
cd /d "%~dp0.." || exit /b 1
set "CID="
for /f %%i in ('docker ps -q --filter "id=%TARGET_INSTANCE_ID%" --filter "label=com.docker.compose.service=api"') do if not defined CID set "CID=%%i"
if not defined CID exit /b 1
docker stop --time 5 %CID% >nul 2>&1
exit /b %errorlevel%
+15
View File
@@ -0,0 +1,15 @@
#!/bin/sh
# Останавливает РОВНО ОДНУ API-реплику: ту, чей X-Instance-Id (= hostname контейнера) передан в
# TARGET_INSTANCE_ID, и оставляет её остановленной. БД, LB и volumes не трогаются. Секреты не печатаются.
# Восстановление отдельно: docker compose up -d (или scripts/start-all.sh)
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
case "$TARGET_INSTANCE_ID" in
*[!A-Za-z0-9._-]*|"") echo "bad instance id" >&2; exit 2 ;;
esac
cd "$(dirname "$0")/.."
# Фильтр по compose-сервису api: LB/БД остановить этим скриптом невозможно.
cid=$(docker ps -q --filter "id=$TARGET_INSTANCE_ID" --filter "label=com.docker.compose.service=api" | head -n 1)
[ -n "$cid" ] || { echo "api container for instance not found" >&2; exit 1; }
# SIGTERM → graceful shutdown (ready=503, drain, закрытие listener); через 5 с — SIGKILL.
docker stop --time 5 "$cid" >/dev/null
+372
View File
@@ -0,0 +1,372 @@
package main
import (
"bytes"
"context"
"errors"
"time"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgxpool"
)
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"`
}
var (
errConflict = errors.New("conflict")
errNotFound = errors.New("not found")
errInvalidMembers = errors.New("invalid members")
)
// Store — единственный источник истины: PostgreSQL. Все запросы параметризованы ($1, $2, …),
// строки SQL не собираются из пользовательских данных.
type Store struct{ pool *pgxpool.Pool }
func newPool(ctx context.Context, url string, maxConns int32) (*pgxpool.Pool, error) {
cfg, err := pgxpool.ParseConfig(url)
if err != nil {
return nil, errors.New("invalid database URL")
}
cfg.MaxConns = maxConns
cfg.MaxConnLifetime = 30 * time.Minute
cfg.MaxConnIdleTime = 5 * time.Minute
cfg.HealthCheckPeriod = 15 * time.Second
cfg.ConnConfig.ConnectTimeout = 3 * time.Second
if cfg.ConnConfig.RuntimeParams == nil {
cfg.ConnConfig.RuntimeParams = map[string]string{}
}
cfg.ConnConfig.RuntimeParams["timezone"] = "UTC"
cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000"
cfg.ConnConfig.RuntimeParams["idle_in_transaction_session_timeout"] = "10000"
cfg.ConnConfig.RuntimeParams["application_name"] = "messenger-api"
// Соединения создаются лениво: API стартует и при недоступной БД (тогда /health/ready даёт 503).
return pgxpool.NewWithConfig(ctx, cfg)
}
// dbFail переводит ошибку БД в ограниченный ответ: ни SQL, ни адреса, ни текста драйвера клиенту не уходят.
func dbFail(err error) *apiError {
var pg *pgconn.PgError
if errors.As(err, &pg) {
// 08 — соединение, 53 — ресурсы, 57 — остановка/отмена, 40 — откат по конкуренции.
switch pg.Code[:2] {
case "08", "53", "57", "40":
return unavailable()
}
return fail(500, "internal_error", "Внутренняя ошибка")
}
// не PgError: обрыв соединения, таймаут, пул исчерпан, БД недоступна
return unavailable()
}
func isPgCode(err error, code string) bool {
var pg *pgconn.PgError
return errors.As(err, &pg) && pg.Code == code
}
// ---- пользователи ----
func (s *Store) createUser(ctx context.Context, u User, passwordHash string) (User, error) {
var created time.Time
err := s.pool.QueryRow(ctx,
`INSERT INTO users (id, username, display_name, password_hash) VALUES ($1::uuid, $2, $3, $4) RETURNING created_at`,
u.ID, u.Username, u.DisplayName, passwordHash).Scan(&created)
if err != nil {
if isPgCode(err, "23505") { // unique_violation: username занят, в том числе при гонке
return User{}, errConflict
}
return User{}, err
}
u.CreatedAt = formatTime(created)
return u, nil
}
func (s *Store) userWithHash(ctx context.Context, username string) (User, string, error) {
var u User
var hash string
var created time.Time
err := s.pool.QueryRow(ctx,
`SELECT id::text, username, display_name, created_at, password_hash FROM users WHERE username = $1`,
username).Scan(&u.ID, &u.Username, &u.DisplayName, &created, &hash)
if errors.Is(err, pgx.ErrNoRows) {
return User{}, "", errNotFound
}
if err != nil {
return User{}, "", err
}
u.CreatedAt = formatTime(created)
return u, hash, nil
}
// ---- сессии ----
func (s *Store) createSession(ctx context.Context, tokenHash []byte, userID string, ttlSecs int) (time.Time, error) {
// Оппортунистическая чистка давно истёкших строк; индекс по expires_at делает её дешёвой.
_, _ = s.pool.Exec(ctx, `DELETE FROM sessions WHERE expires_at < now() - interval '1 day'`)
var expires time.Time
err := s.pool.QueryRow(ctx,
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2::uuid, now() + make_interval(secs => $3::float8)) RETURNING expires_at`,
tokenHash, userID, float64(ttlSecs)).Scan(&expires)
return expires, err
}
// sessionUser возвращает владельца действующей (не истёкшей и не отозванной) сессии.
// Срок проверяется по часам PostgreSQL, поэтому он не зависит от рестарта API.
func (s *Store) sessionUser(ctx context.Context, tokenHash []byte) (User, error) {
var u User
var created time.Time
err := s.pool.QueryRow(ctx,
`SELECT u.id::text, u.username, u.display_name, u.created_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()`,
tokenHash).Scan(&u.ID, &u.Username, &u.DisplayName, &created)
if errors.Is(err, pgx.ErrNoRows) {
return User{}, errNotFound
}
if err != nil {
return User{}, err
}
u.CreatedAt = formatTime(created)
return u, nil
}
func (s *Store) revokeSession(ctx context.Context, tokenHash []byte) error {
_, err := s.pool.Exec(ctx,
`UPDATE sessions SET revoked_at = now() WHERE token_hash = $1 AND revoked_at IS NULL`, tokenHash)
return err
}
// ---- чаты ----
// createChat — составная операция: чат и ВСЕ участники появляются в одной транзакции.
// Любая ошибка (например, несуществующий участник → FK) откатывает всё: «половинчатых» чатов не бывает.
func (s *Store) createChat(ctx context.Context, c Chat, creatorID string) (Chat, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return Chat{}, err
}
defer func() { _ = tx.Rollback(context.Background()) }() // no-op после Commit
var created time.Time
if err := tx.QueryRow(ctx,
`INSERT INTO chats (id, title, created_by) VALUES ($1::uuid, $2, $3::uuid) RETURNING created_at`,
c.ID, c.Title, creatorID).Scan(&created); err != nil {
return Chat{}, err
}
if _, err := tx.Exec(ctx,
`INSERT INTO chat_members (chat_id, user_id) SELECT $1::uuid, m::uuid FROM unnest($2::text[]) AS m`,
c.ID, c.MemberIDs); err != nil {
if isPgCode(err, "23503") { // foreign_key_violation: неизвестный участник
return Chat{}, errInvalidMembers
}
return Chat{}, err
}
if err := tx.Commit(ctx); err != nil {
return Chat{}, err
}
c.CreatedAt = formatTime(created)
return c, nil
}
const chatColumns = `c.id::text, c.title, c.created_at,
ARRAY(SELECT m2.user_id::text FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.user_id)`
func scanChat(row pgx.Row) (Chat, time.Time, error) {
var c Chat
var created time.Time
if err := row.Scan(&c.ID, &c.Title, &created, &c.MemberIDs); err != nil {
return Chat{}, time.Time{}, err
}
c.CreatedAt = formatTime(created)
return c, created, nil
}
func (s *Store) getChat(ctx context.Context, actorID, chatID string) (Chat, error) {
c, _, err := scanChat(s.pool.QueryRow(ctx,
`SELECT `+chatColumns+` FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1::uuid WHERE c.id = $2::uuid`,
actorID, chatID))
if errors.Is(err, pgx.ErrNoRows) {
return Chat{}, errNotFound
}
return c, err
}
func (s *Store) isMember(ctx context.Context, actorID, chatID string) (bool, error) {
var ok bool
err := s.pool.QueryRow(ctx,
`SELECT EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $1::uuid AND user_id = $2::uuid)`,
chatID, actorID).Scan(&ok)
return ok, err
}
// listChats: keyset-пагинация по (created_at, id); запрашивается limit+1 строк, чтобы точно знать, есть ли следующая.
func (s *Store) listChats(ctx context.Context, actorID string, limit int, after *time.Time, afterID string) ([]Chat, string, error) {
sql := `SELECT ` + chatColumns + ` FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1::uuid`
args := []any{actorID}
if after != nil {
sql += ` WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid)`
args = append(args, *after, afterID)
}
sql += ` ORDER BY c.created_at, c.id LIMIT ` + placeholder(len(args)+1)
args = append(args, limit+1)
rows, err := s.pool.Query(ctx, sql, args...)
if err != nil {
return nil, "", err
}
defer rows.Close()
items := []Chat{}
var lastTime time.Time
for rows.Next() {
c, created, err := scanChat(rows)
if err != nil {
return nil, "", err
}
if len(items) == limit { // лишняя строка: следующая страница существует
return items, encodeCursor("chats", actorID, lastTime, items[len(items)-1].ID), rows.Err()
}
items = append(items, c)
lastTime = created
}
return items, "", rows.Err()
}
func placeholder(n int) string { return "$" + itoa(n) }
// ---- сообщения ----
func (s *Store) createMessage(ctx context.Context, m Message) (Message, error) {
var created time.Time
err := s.pool.QueryRow(ctx,
`INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1::uuid, $2::uuid, $3::uuid, $4) RETURNING created_at`,
m.ID, m.ChatID, m.SenderID, m.Text).Scan(&created)
if err != nil {
return Message{}, err
}
m.CreatedAt = formatTime(created)
return m, nil
}
// createMessageIdempotent: ключ и сообщение — одна транзакция. Возвращает (сообщение, replayed, ошибка).
// errConflict — тот же ключ с другим телом. Дубль невозможен: PRIMARY KEY ключа сериализует
// конкурентные повторы (в том числе с разных реплик), проигравший ждёт коммита победителя.
func (s *Store) createMessageIdempotent(ctx context.Context, m Message, key, path string, reqHash []byte) (Message, bool, error) {
tx, err := s.pool.Begin(ctx)
if err != nil {
return Message{}, false, err
}
defer func() { _ = tx.Rollback(context.Background()) }()
// Ключ старше 24 часов считается свободным.
if _, err := tx.Exec(ctx,
`DELETE FROM idempotency_keys WHERE user_id = $1::uuid AND method = 'POST' AND path = $2 AND key = $3
AND created_at < now() - interval '24 hours'`, m.SenderID, path, key); err != nil {
return Message{}, false, err
}
tag, err := tx.Exec(ctx,
`INSERT INTO idempotency_keys (user_id, method, path, key, request_hash) VALUES ($1::uuid, 'POST', $2, $3, $4)
ON CONFLICT DO NOTHING`, m.SenderID, path, key, reqHash)
if err != nil {
return Message{}, false, err
}
if tag.RowsAffected() == 0 {
// Ключ уже занят закоммиченной записью: отдаём сохранённый результат или 409.
var stored []byte
var created time.Time
var prev Message
err := tx.QueryRow(ctx,
`SELECT k.request_hash, m.id::text, m.chat_id::text, m.sender_id::text, m.text, m.created_at
FROM idempotency_keys k JOIN messages m ON m.id = k.message_id
WHERE k.user_id = $1::uuid AND k.method = 'POST' AND k.path = $2 AND k.key = $3`,
m.SenderID, path, key).Scan(&stored, &prev.ID, &prev.ChatID, &prev.SenderID, &prev.Text, &created)
if err != nil {
return Message{}, false, err
}
if !bytes.Equal(stored, reqHash) {
return Message{}, false, errConflict
}
prev.CreatedAt = formatTime(created)
return prev, true, nil
}
var created time.Time
if err := tx.QueryRow(ctx,
`INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1::uuid, $2::uuid, $3::uuid, $4) RETURNING created_at`,
m.ID, m.ChatID, m.SenderID, m.Text).Scan(&created); err != nil {
return Message{}, false, err
}
if _, err := tx.Exec(ctx,
`UPDATE idempotency_keys SET message_id = $4::uuid WHERE user_id = $1::uuid AND method = 'POST' AND path = $2 AND key = $3`,
m.SenderID, path, key, m.ID); err != nil {
return Message{}, false, err
}
if err := tx.Commit(ctx); err != nil {
return Message{}, false, err
}
m.CreatedAt = formatTime(created)
return m, false, nil
}
func (s *Store) listMessages(ctx context.Context, chatID string, limit int, after *time.Time, afterID string) ([]Message, string, error) {
sql := `SELECT id::text, chat_id::text, sender_id::text, text, created_at FROM messages WHERE chat_id = $1::uuid`
args := []any{chatID}
if after != nil {
sql += ` AND (created_at, id) > ($2::timestamptz, $3::uuid)`
args = append(args, *after, afterID)
}
sql += ` ORDER BY created_at, id LIMIT ` + placeholder(len(args)+1)
args = append(args, limit+1)
rows, err := s.pool.Query(ctx, sql, args...)
if err != nil {
return nil, "", err
}
defer rows.Close()
items := []Message{}
var lastTime time.Time
for rows.Next() {
var m Message
var created time.Time
if err := rows.Scan(&m.ID, &m.ChatID, &m.SenderID, &m.Text, &created); err != nil {
return nil, "", err
}
if len(items) == limit {
return items, encodeCursor("messages", chatID, lastTime, items[len(items)-1].ID), rows.Err()
}
m.CreatedAt = formatTime(created)
items = append(items, m)
lastTime = created
}
return items, "", rows.Err()
}
// ready: БД отвечает и схема доведена до последней миграции.
func (s *Store) ready(ctx context.Context) error {
versions := migrationVersions()
var n int
if err := s.pool.QueryRow(ctx,
`SELECT count(*) FROM schema_migrations WHERE version = ANY($1::text[])`, versions).Scan(&n); err != nil {
return err
}
if n != len(versions) {
return errors.New("schema is not up to date")
}
return nil
}