Author SHA1 Message Date
kk10 15492d7894 docs(report): update session cache TTL description 2026-10-10 11:02:29 +03:00
kk10 c8470beeee perf(pagination): split list queries into first-page and after-cursor variants 2026-10-10 10:51:50 +03:00
kk10 a288193cda fix(httpx): reject request bodies with trailing data after JSON 2026-10-10 10:41:58 +03:00
kk10 d25054843c fix(auth): cap session cache TTL by remaining session lifetime 2026-10-10 10:38:55 +03:00
kk10 af88065a1c docs: add PR link to report 2026-10-08 15:44:14 +03:00
kk10 9ec1eae7b8 docs: write lab 2 report 2026-10-08 15:21:18 +03:00
kk10 f86d79a584 refactor: remove unused in-memory store 2026-10-08 00:00:04 +03:00
kk10 497f677453 docs: add track 2 and test evidence 2026-10-07 23:48:38 +03:00
kk10 0e62ba9660 test(auth): add session expiry test with short ttl 2026-10-07 17:13:09 +03:00
kk10 fff2cb5b37 test(auth): add redis and database failure tests 2026-10-07 17:07:05 +03:00
kk10 d7002b4dfe feat(httpx): return 503 when a dependency is unavailable 2026-10-06 18:45:31 +03:00
kk10 b540577cf9 test(auth): add wrong password and logout tests 2026-10-06 18:33:56 +03:00
kk10 5bd210b59d feat(auth): cache sessions in redis with postgres fallback 2026-10-06 15:36:52 +03:00
kk10 f7e1866d4e feat(config): add redis url secret 2026-10-06 13:18:46 +03:00
kk10 06e9af1ba6 feat(compose): add redis service 2026-10-06 13:09:00 +03:00
kk10 6469ed475b refactor(compose): rename backend service to api 2026-10-06 13:05:16 +03:00
kk10 ffe842f312 docs: add explain analyze results for message history 2026-10-05 23:55:20 +03:00
kk10 58177470b7 chore(compose): publish postgres port on localhost 2026-10-05 23:55:12 +03:00
kk10 81cea31c81 test(chat): add create chat rollback test 2026-10-05 23:06:18 +03:00
kk10 66808c6c80 test(auth): add concurrent registration race test 2026-10-05 22:43:09 +03:00
kk10 2d413ab704 feat(middleware): add request timeout 2026-10-05 22:29:18 +03:00
kk10 62412bd465 test: add restart hook for persistence test 2026-10-05 22:18:52 +03:00
kk10 7b92ca2366 feat(auth): delete expired sessions hourly 2026-10-05 15:11:24 +03:00
kk10 79036b0f18 test: authenticate student tests with session tokens 2026-10-05 13:42:00 +03:00
kk10 385a8c0312 feat(message): store messages in Postgres 2026-10-05 13:26:21 +03:00
kk10 04f7c046b6 feat(chat): store chats in Postgres 2026-10-05 12:54:51 +03:00
kk10 c99f6f02c5 refactor(httpx): rename WriteInternal to WriteInternalError 2026-10-05 12:47:41 +03:00
kk10 86f4aadead refactor(httpx): rename WriteInternal to WriteInternalError 2026-10-05 11:57:31 +03:00
kk10 a8525778a3 feat(auth): add session login, logout and bearer middleware 2026-10-05 11:54:36 +03:00
kk10 b94e7813ee refactor(httpx): drop duplicate WriteError, add WriteInternal 2026-10-05 11:41:34 +03:00
kk10 5d6f5a397f refactor(db): drop Querier and select only user id for session lookup 2026-10-04 23:08:11 +03:00
kk10 527c1748f8 feat(user): store users in Postgres with password hashes 2026-10-04 22:49:42 +03:00
kk10 bbcde1e95e build(docker): bump Go image to 1.27.1 2026-10-04 22:07:21 +03:00
kk10 01a9cc3398 feat(credentials): add password hashing and token helpers 2026-10-04 22:04:47 +03:00
kk10 862d22c228 feat(postgres): add pool and error code helpers 2026-10-04 21:41:39 +03:00
kk10 e1f2cb01e0 feat(db): add schema, sqlc queries and generated code 2026-10-04 21:25:07 +03:00
kk10 492e0be15c feat(db): connect to PostgreSQL and check it in /health/ready 2026-10-03 12:36:05 +03:00
kk10 60fad0fca7 feat(config): add database secret file and session TTL settings 2026-10-03 12:32:09 +03:00
kk10 4c1d08f8a8 feat(db): add postgres, goose migrations and initial schema 2026-10-03 11:40:26 +03:00
kk10 2f279a1715 chore: port lab 1 solution 2026-10-02 11:45:26 +03:00
82 changed files with 5088 additions and 21 deletions
+5 -6
View File
@@ -1,11 +1,10 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
MAX_INFLIGHT_REQUESTS=0
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
LOG_LEVEL=INFO
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
+21
View File
@@ -0,0 +1,21 @@
FROM golang:1.27.1 AS build
WORKDIR /src
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o /out/server ./cmd/server
FROM gcr.io/distroless/static-debian12:nonroot
WORKDIR /app
COPY --from=build /out/server .
COPY contracts ./contracts
COPY web/swagger ./web/swagger
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD ["/app/server", "healthcheck"]
ENTRYPOINT ["/app/server"]
+8
View File
@@ -0,0 +1,8 @@
FROM golang:1.27.1-alpine3.24 AS build
ENV CGO_ENABLED=0
RUN go install github.com/pressly/goose/v3/cmd/goose@v3.28.0
FROM alpine:3.24
COPY --from=build /go/bin/goose /usr/local/bin/goose
COPY db/migrations /migrations
ENTRYPOINT ["sh", "-c", "goose -dir /migrations postgres \"$(cat /run/secrets/database_url)\" up"]
+2
View File
@@ -24,3 +24,5 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
-include student.mk
+130 -15
View File
@@ -1,37 +1,152 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Каменски Лин, БПИ2301
- Целевая оценка; выбранный трек 5, если нужен: 5; трек 2
- Commit/PR: [Pull Request 20](https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/20)
- Использованные источники, библиотеки и помощь ИИ: материалы лабораторной; Go, chi, pgx v5, sqlc, goose, PostgreSQL 18.6, Redis 8.8.3; Claude, ChatGPT - для ускорения работы и оформления отчёта
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требуются Go 1.26+ и Docker с Compose. Образы: PostgreSQL 18.6, Redis 8.8.3.
Создать локальные secrets - файлы в `secrets/`, в каждый записать значение без лишних символов:
- `database_url.txt` - URL PostgreSQL для API;
- `cache_url.txt` - URL Redis;
- `postgres_password.txt` - пароль пользователя `messenger`;
- `test_database_url.txt` - URL БД для тестов.
Пример (значения заменить своими):
```bash
mkdir -p secrets
printf '%s' 'CHANGE_ME' > secrets/postgres_password.txt
printf '%s' 'postgres://messenger:CHANGE_ME@postgres:5432/messenger?sslmode=disable' > secrets/database_url.txt
printf '%s' 'redis://redis:6379/0' > secrets/cache_url.txt
printf '%s' 'postgres://messenger:CHANGE_ME@127.0.0.1:5432/messenger?sslmode=disable' > secrets/test_database_url.txt
```
Скопировать шаблон переменных окружения:
```bash
cp .env.example .env
```
Сборка и запуск (сервис `migrate` применяет миграции goose автоматически):
```bash
docker compose up --build -d
```
Готовность API проверяется запросом к `/health/ready`; после этого API доступен на http://localhost:8080.
Тесты:
```bash
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make contract-go
make race-go
make failure-go
```
Безопасная остановка (данные в volume `pgdata` сохраняются):
```bash
docker compose down
```
Намеренное удаление учебных данных:
```bash
docker compose down -v
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Процессы/хранилища: `api` (Go), `postgres`, `redis`, одноразовый `migrate` (goose). Источник истины - PostgreSQL. Redis хранит только кэш сессий: TTL записи = min(60 с, оставшийся срок сессии до `expires_at`); при logout запись удаляется сначала из PostgreSQL, затем из Redis. При недоступности Redis API обходит кэш и читает сессию из PostgreSQL; при недоступности PostgreSQL API отвечает `503`. Создание чата выполняется в одной транзакции (откат проверяется `TestCreateChatRollback`).
Пароли хешируются bcrypt; перед этим пароль проходит через SHA-256, чтобы обойти ограничение bcrypt в 72 байта.
Из lab1 перенесены слои `handler` (HTTP) и `service` (бизнес-логика). Хранилище в памяти (`store`) заменено кодом доступа к PostgreSQL (sqlc, pgxpool) и удалено; `X-User-Id` заменён на Bearer-сессии.
Переменные `.env.example`: `APP_HOST`, `APP_PORT` - адрес и порт API; `MAX_INFLIGHT_REQUESTS` - ограничитель запросов из lab1 (0 - выключен); `SESSION_TTL_SECONDS` - срок жизни сессии; `LOG_LEVEL` - уровень логов; `DATABASE_URL_FILE`, `CACHE_URL_FILE` - пути к secrets с URL PostgreSQL и Redis.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `make test` | `PASS` | `evidence/make-test.txt` |
| Уровень 3 |
| Сохранность данных и сессии после рестарта | `make test-persistence ACTION_SCRIPT=scripts/restart.sh`; скрипт выполняет `docker compose restart postgres redis api`, volumes сохраняются | `PASS`: данные и существующая сессия сохранены | `evidence/make-test-persistence.txt` |
| Повторный запуск миграций без дублирования данных | повторный запуск сервиса `migrate` | `no migrations to run` | `evidence/migrate-repeat.txt` |
| Уникальность username | `make contract-go` (`TestDuplicateUsername`) | `PASS` | `evidence/make-contract-go.txt` |
| Срок жизни сессии | `make failure-go` (`TestSessionExpiry`) | `PASS` | `evidence/make-failure-go.txt` |
| Уровень 4 |
| Гонка регистрации одного username | `make race-go` (`TestConcurrentRegistration`) | `PASS` | `evidence/make-race-go.txt` |
| Rollback составной операции | `make contract-go` (`TestCreateChatRollback`) | `PASS` | `evidence/make-contract-go.txt` |
| Индекс истории, пагинация без полного scan | `EXPLAIN (ANALYZE, BUFFERS)`, 20 000 сообщений | Seq Scan + Sort 5,2 мс, 507 буферов → Index Scan 0,03 мс, 4 буфера | `evidence/explain-history.txt` |
| Logout, неверный пароль | `make contract-go` (`TestLogout`, `TestLoginWrongPassword`) | `PASS` | `evidence/make-contract-go.txt` |
| Недоступность Redis и БД | `make failure-go` (`TestRedisDown`, `TestDatabaseDown`) | `PASS` | `evidence/make-failure-go.txt` |
| Уровень 5 |
| Трек 2: стоимость записи | вставка 100 000 сообщений (чаты 60 000 / 5×5 000 / 200×75) для вариантов A, B, C | B и C медленнее A; дополнительные индексы занимают 4880–5776 КБ | `evidence/track2-insert-cost.txt` |
| Трек 2: план запроса | `EXPLAIN (ANALYZE, BUFFERS)` для A, B, C на чатах `big` и `small-1` | A: Seq Scan, 2264 буфера; B: Index Scan, 8-9 буферов; C: Index Scan + Sort, 1730 буферов на `big` | `evidence/track2-explain.txt` |
| Трек 2: backup → restore | `pg_dump -Fc` → `pg_restore` в `research_restore` | `count` = 100 000, хеш таблицы и хеш выбранной страницы совпали | `evidence/track2-backup-restore.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Для сравнения использовались три варианта индексации таблицы `messages`:
- A - только первичный ключ `(PK)`, без дополнительного индекса;
- B - индекс `(chat_id, created_at, id)`;
- C - индекс `(chat_id, id)`.
Для каждого варианта выполнялись эксперименты с записью и чтением. Дополнительно проверялись резервное копирование и восстановление данных.
**Гипотезы**:
1. Индекс `(chat_id, created_at, id)` (B) позволит получить страницу из 50 сообщений за сопоставимое время и с сопоставимым числом обращений к данным в малом и большом чате;
2. Индекс `(chat_id, id)` (C) хуже индекса `(chat_id, created_at, id)` (B), поскольку может потребоваться дополнительная сортировка по `created_at, id`;
3. Каждый индекс замедляет вставку и занимает место.
**Методика**:
Эксперимент проводился в Docker Desktop с доступными 12 ядрами процессора и примерно 7,7 ГБ оперативной памяти. PostgreSQL 18.6, отдельная БД `research`, 100 000 сообщений: 1 чат на 60 000, 5 по 5 000, 200 по 75. Данные синтетические, сгенерированы один раз во вспомогательной таблице `messages_seed`.
Запись: для каждого варианта выполнено по 3 измерения времени вставки 100 000 одинаковых строк; перед каждым измерением таблица очищалась через TRUNCATE. Для вариантов B и C индекс создавался до начала измерений.
Чтение: для каждого варианта выполнено чтение страницы из 50 сообщений после курсора из середины истории, `EXPLAIN (ANALYZE, BUFFERS)`, чаты `big` и `small-1`, 2 измерения (каждый запрос выполнялся дважды, в таблице приведено второе измерение, когда данные уже в кэше).
Backup сделан при индексе B. Проверка: `count(*)`, `md5` по всем строкам таблицы и `md5` по странице из 50 сообщений чата `big` (тот же курсор, что в `EXPLAIN`); значения хэша в `research` и `research_restore` совпали.
Выполненные команды видны в выводе сессий psql в `evidence/track2-*.txt`.
**Результаты экспериментов**:
Запись:
| Вариант | Измерения, мс | Размер PK/индексов, КБ |
| --- | --- | --- |
| A | 990, 977, 978 | 3104 |
| B | 1655, 1640, 1157 | 8880 |
| C | 1223, 1181, 1185 | 7984 |
Чтение:
| Вариант | `big` (60 000) | `small-1` (75) |
| --- | --- | --- |
| A | 2264 / 10,3 мс | 2264 / 6,2 мс |
| B | 8 / 0,06 мс | 9 / 0,10 мс |
| C | 1730 / 13,6 мс | 10 / 0,17 мс |
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Вставка 100 000 сообщений без индекса (A) | минимальная стоимость записи | 977–990 мс | - |
| Вставка 100 000 сообщений с индексом `(chat_id, created_at, id)` (B) | вставка медленнее | 1157–1655 мс; индекс 5776 КБ | - |
| Вставка 100 000 сообщений с индексом `(chat_id, id)` (C) | вставка медленнее | 1181–1223 мс; индекс 4880 КБ | - |
| Запрос страницы без индекса (A) | стоимость зависит от размера таблицы | `Seq Scan`, 2264 буфера | - |
| Запрос страницы с индексом `(chat_id, created_at, id)` (B) | стоимость слабо зависит от размера чата | `Index Scan`, 8–9 буферов, без `Sort` | - |
| Запрос страницы с индексом `(chat_id, id)` (C) | хуже B на большом чате | `Index Scan` + `Sort`, 1730 буферов на `big` | - |
| `pg_dump -Fc` → `pg_restore` | полное восстановление данных | 4,1 МБ; backup 0,69 с; restore 0,54 с; хэши совпали | 0,54 с; потеря - изменения после последнего backup |
**Вывод**: Гипотеза 1 подтверждена: с индексом B страница читается за 8-9 буферов и 0,06-0,10 мс и в большом, и в малом чате. Гипотеза 2 подтверждена: на большом чате с индексом C читается 1730 буферов за 13,6 мс против 8 буферов и 0,06 мс с индексом B, потому что условие курсора не входит в индекс и нужна сортировка. Гипотеза 3 подтверждена: оба индекса замедляют вставку (977-990 мс без индекса, 1157-1655 мс с B, 1181-1223 мс с C) и занимают место (дополнительно 5776 КБ у B и 4880 КБ у C). Backup и restore восстановили 100 000 сообщений без потери проверенных данных; для истории сообщений выбран индекс B.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Сервер и volume общие для `messenger`, `research` и `research_restore`: эксперимент подтверждает корректность дампа, но не сохранность данных при отказе диска, так как копия лежит на том же носителе.
- Данные синтетические; размеры индексов и степень сжатия дампа на реальных данных будут другими.
- Один курсор из середины истории; каждый запрос выполнялся дважды, в результатах приведён второй прогон при заполненном кэше.
- Время backup и restore включает накладные расходы `docker compose exec`; параллельной записи во время backup не было, консистентность дампа под нагрузкой не проверялась.
- Redis в backup не входит: это кэш, источник истины PostgreSQL.
- После logout при недоступном Redis токен может приниматься до истечения кэш-TTL (до 60 с).
+18
View File
@@ -0,0 +1,18 @@
package main
import (
"log"
"os"
"mtusi2026-messenger/internal/app"
)
func main() {
if len(os.Args) > 1 && os.Args[1] == "healthcheck" {
os.Exit(app.Healthcheck())
}
if err := app.Run(); err != nil {
log.Fatal(err)
}
}
+51
View File
@@ -0,0 +1,51 @@
-- +goose Up
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL
CONSTRAINT users_display_name_not_blank CHECK (display_name ~ '\S'),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE sessions (
token_hash text 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
);
CREATE INDEX idx_sessions_expires_at ON sessions (expires_at);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL
CONSTRAINT chats_title_not_blank CHECK (title ~ '\S'),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX idx_chat_members_user_id ON chat_members (user_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT,
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX idx_messages_chat_history ON messages (chat_id, created_at, id);
-- +goose Down
DROP TABLE messages;
DROP TABLE chat_members;
DROP TABLE chats;
DROP TABLE sessions;
DROP TABLE users;
+73
View File
@@ -0,0 +1,73 @@
-- name: CreateChat :one
INSERT INTO chats (
id,
title
) VALUES (
sqlc.arg(id),
sqlc.arg(title)
)
RETURNING *;
-- name: AddChatMembers :exec
INSERT INTO chat_members (
chat_id,
user_id
)
SELECT
sqlc.arg(chat_id)::uuid,
unnest(sqlc.arg(user_ids)::uuid[]);
-- name: IsChatMember :one
SELECT EXISTS (
SELECT 1 FROM chat_members
WHERE chat_id = sqlc.arg(chat_id)
AND user_id = sqlc.arg(user_id)
);
-- name: GetChat :one
SELECT
c.*,
ARRAY(
SELECT cm.user_id FROM chat_members cm
WHERE cm.chat_id = c.id
ORDER BY cm.user_id
)::uuid[] AS member_ids
FROM chats c
WHERE c.id = sqlc.arg(id)
AND EXISTS (
SELECT 1 FROM chat_members m
WHERE m.chat_id = c.id
AND m.user_id = sqlc.arg(user_id)
);
-- name: ListChatsFirstPage :many
SELECT
c.*,
ARRAY(
SELECT cm.user_id FROM chat_members cm
WHERE cm.chat_id = c.id
ORDER BY cm.user_id
)::uuid[] AS member_ids
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = sqlc.arg(user_id)
ORDER BY c.created_at, c.id
LIMIT sqlc.arg(lim);
-- name: ListChatsAfter :many
SELECT
c.*,
ARRAY(
SELECT cm.user_id FROM chat_members cm
WHERE cm.chat_id = c.id
ORDER BY cm.user_id
)::uuid[] AS member_ids
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = sqlc.arg(user_id)
AND (c.created_at, c.id) > (
sqlc.arg(after_created_at)::timestamptz,
sqlc.arg(after_id)::uuid
)
ORDER BY c.created_at, c.id
LIMIT sqlc.arg(lim);
+34
View File
@@ -0,0 +1,34 @@
-- name: CreateMessage :one
INSERT INTO messages (
id,
chat_id,
sender_id,
text
)
SELECT
sqlc.arg(id)::uuid,
sqlc.arg(chat_id)::uuid,
sqlc.arg(sender_id)::uuid,
sqlc.arg(text)::text
WHERE EXISTS (
SELECT 1 FROM chat_members
WHERE chat_id = sqlc.arg(chat_id)
AND user_id = sqlc.arg(sender_id)
)
RETURNING *;
-- name: ListMessagesFirstPage :many
SELECT * FROM messages
WHERE chat_id = sqlc.arg(chat_id)
ORDER BY created_at, id
LIMIT sqlc.arg(lim);
-- name: ListMessagesAfter :many
SELECT * FROM messages
WHERE chat_id = sqlc.arg(chat_id)
AND (created_at, id) > (
sqlc.arg(after_created_at)::timestamptz,
sqlc.arg(after_id)::uuid
)
ORDER BY created_at, id
LIMIT sqlc.arg(lim);
+24
View File
@@ -0,0 +1,24 @@
-- name: CreateSession :exec
INSERT INTO sessions (
token_hash,
user_id,
expires_at
) VALUES (
sqlc.arg(token_hash),
sqlc.arg(user_id),
sqlc.arg(expires_at)
);
-- name: GetActiveSession :one
SELECT user_id, expires_at FROM sessions
WHERE token_hash = sqlc.arg(token_hash)
AND expires_at > now();
-- name: DeleteSession :execrows
DELETE FROM sessions
WHERE token_hash = sqlc.arg(token_hash)
AND expires_at > now();
-- name: DeleteExpiredSessions :execrows
DELETE FROM sessions
WHERE expires_at <= now();
+21
View File
@@ -0,0 +1,21 @@
-- name: CreateUser :one
INSERT INTO users (
id,
username,
display_name,
password_hash
) VALUES (
sqlc.arg(id),
sqlc.arg(username),
sqlc.arg(display_name),
sqlc.arg(password_hash)
)
RETURNING id, username, display_name, created_at;
-- name: GetUser :one
SELECT id, username, display_name, created_at FROM users
WHERE id = sqlc.arg(id);
-- name: GetUserByUsername :one
SELECT * FROM users
WHERE username = sqlc.arg(username);
+68
View File
@@ -0,0 +1,68 @@
services:
api:
build:
context: .
dockerfile: Dockerfile
image: mtusi-messenger:lab2
ports:
- "127.0.0.1:8080:${APP_PORT}"
env_file:
- .env
secrets:
- database_url
- cache_url
depends_on:
migrate:
condition: service_completed_successfully
restart: unless-stopped
postgres:
image: postgres:18.6
ports:
- "127.0.0.1:5432:5432"
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql
healthcheck:
test: ["CMD-SHELL", "pg_isready -h 127.0.0.1 -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
migrate:
build:
context: .
dockerfile: Dockerfile.migrate
secrets:
- database_url
depends_on:
postgres:
condition: service_healthy
restart: "no"
redis:
image: redis:8.8.3-alpine3.23
command: ["redis-server", "--save", "", "--appendonly", "no"]
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
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:
+90
View File
@@ -0,0 +1,90 @@
> docker compose exec postgres psql -U messenger -d messenger
psql (18.6 (Debian 18.6-1.pgdg13+2))
Type "help" for help.
messenger=# INSERT INTO users (id, username, display_name, password_hash)
VALUES ('00000000-0000-0000-0000-0000000000a1', 'explain_user', 'Explain', 'x');
INSERT 0 1
messenger=# INSERT INTO chats (id, title)
VALUES ('00000000-0000-0000-0000-0000000000b1', 'explain chat');
INSERT 0 1
messenger=# INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), '00000000-0000-0000-0000-0000000000b1',
'00000000-0000-0000-0000-0000000000a1', 'msg ' || g,
now() - (g || ' seconds')::interval
FROM generate_series(1, 20000) g;
INSERT 0 20000
messenger=# ANALYZE messages;
ANALYZE
messenger=# BEGIN;
BEGIN
messenger=*# DROP INDEX idx_messages_chat_history;
DROP INDEX
messenger=*# EXPLAIN (ANALYZE, BUFFERS)
SELECT * FROM messages
WHERE chat_id = '00000000-0000-0000-0000-0000000000b1'
ORDER BY created_at, id LIMIT 50;
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------
Limit (cost=1405.39..1405.51 rows=50 width=65) (actual time=4.083..4.088 rows=50.00 loops=1)
Buffers: shared hit=491
-> Sort (cost=1405.39..1455.39 rows=20000 width=65) (actual time=4.082..4.084 rows=50.00 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 38kB
Buffers: shared hit=491
-> Seq Scan on messages (cost=0.00..741.00 rows=20000 width=65) (actual time=0.154..1.624 rows=20000.00 loops=1)
Filter: (chat_id = '00000000-0000-0000-0000-0000000000b1'::uuid)
Buffers: shared hit=491
Planning:
Buffers: shared hit=30
Planning Time: 0.218 ms
Execution Time: 4.102 ms
(13 rows)
messenger=*# ROLLBACK;
ROLLBACK
messenger=# EXPLAIN (ANALYZE, BUFFERS)
SELECT * FROM messages
WHERE chat_id = '00000000-0000-0000-0000-0000000000b1'
ORDER BY created_at, id LIMIT 50;
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..10.76 rows=50 width=65) (actual time=0.008..0.018 rows=50.00 loops=1)
Buffers: shared hit=6
-> Index Scan using idx_messages_chat_history on messages (cost=0.41..4139.54 rows=20000 width=65) (actual time=0.006..0.014 rows=50.00 loops=1)
Index Cond: (chat_id = '00000000-0000-0000-0000-0000000000b1'::uuid)
Index Searches: 1
Buffers: shared hit=6
Planning:
Buffers: shared hit=22
Planning Time: 0.141 ms
Execution Time: 0.029 ms
(10 rows)
messenger=# SELECT created_at AS cur_ts, id AS cur_id FROM messages
WHERE chat_id = '00000000-0000-0000-0000-0000000000b1'
ORDER BY created_at, id OFFSET 15000 LIMIT 1 \gset
EXPLAIN (ANALYZE, BUFFERS)
SELECT * FROM messages
WHERE chat_id = '00000000-0000-0000-0000-0000000000b1'
AND (created_at, id) > (:'cur_ts', :'cur_id')
ORDER BY created_at, id LIMIT 50;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..17.36 rows=50 width=65) (actual time=0.018..0.031 rows=50.00 loops=1)
Buffers: shared hit=5
-> Index Scan using idx_messages_chat_history on messages (cost=0.41..1694.52 rows=4999 width=65) (actual time=0.017..0.026 rows=50.00 loops=1)
Index Cond: ((chat_id = '00000000-0000-0000-0000-0000000000b1'::uuid) AND (ROW(created_at, id) > ROW('2026-10-05 19:13:13.4346+00'::timestamp with time zone, '9bb7f5ae-1191-44f9-aaa9-fb1ebf4cc701'::uuid)))
Index Searches: 1
Buffers: shared hit=5
Planning Time: 0.071 ms
Execution Time: 0.044 ms
(8 rows)
messenger=#
Binary file not shown.
+9
View File
@@ -0,0 +1,9 @@
> make failure-go
go test -tags=failure ./student-tests/... -v -args -base-url=http://localhost:8080
=== RUN TestRedisDown
--- PASS: TestRedisDown (2.12s)
=== RUN --- PASS: TestDatabaseDown (10.90s)
=== RUN TestSessionExpiry
--- PASS: TestSessionExpiry (5.77s)
PASS
ok mtusi2026-messenger/student-tests 18.803s
+9
View File
@@ -0,0 +1,9 @@
> make race-go
go test -tags=race ./student-tests/... -race -v -args -base-url=http://localhost:8080
=== RUN TestConcurrentMessages
race_test.go:98: PASS: 10 concurrent clients sent 100 messages, exactly 100 unique messages persisted
--- PASS: TestConcurrentMessages (0.31s)
=== RUN TestConcurrentRegistration
--- PASS: TestConcurrentRegistration (0.12s)
PASS
ok mtusi2026-messenger/student-tests 1.443s
+4
View File
@@ -0,0 +1,4 @@
> make test-persistence ACTION_SCRIPT=scripts/restart.sh
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.
+3
View File
@@ -0,0 +1,3 @@
> make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+4
View File
@@ -0,0 +1,4 @@
> docker compose run --rm --no-deps migrate
Container mtusi2026lab2-migrate-run-481a17e62bda Creating
Container mtusi2026lab2-migrate-run-481a17e62bda Created
2026/10/07 20:39:09 goose: no migrations to run. current version: 1
+70
View File
@@ -0,0 +1,70 @@
research=# DROP TABLE messages_seed;
DROP TABLE
Time: 4.369 ms
research=# CREATE INDEX idx_messages_chat_history ON messages (chat_id, created_at, id);
CREATE INDEX
Time: 75.459 ms
research=# ANALYZE messages;
ANALYZE
Time: 92.896 ms
research=# SELECT count(*) FROM messages;
count
--------
100000
(1 row)
Time: 7.997 ms
research=# SELECT md5(string_agg(id::text || chat_id::text || created_at::text || text, '' ORDER BY id)) AS full_hash FROM messages;
full_hash
----------------------------------
3b0b6c7f0769218c3d3d1a7b660f521c
(1 row)
Time: 74.820 ms
research=# SELECT md5(string_agg(id::text || text, '' ORDER BY created_at, id)) AS page_hash FROM (SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'big') AND (created_at, id) > ('2026-01-15 00:00+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50) p;
page_hash
----------------------------------
1b111bf87f61b52ef916f31037c4acb5
(1 row)
Time: 0.736 ms
research=# \q
> Measure-Command { docker compose exec postgres pg_dump -U messenger -d research -Fc -f /tmp/research.dump } | Select-Object TotalSeconds
TotalSeconds
------------
0,6917214
> docker compose exec postgres psql -U messenger -d postgres -c "CREATE DATABASE research_restore;"
CREATE DATABASE
> Measure-Command { docker compose exec postgres pg_restore -U messenger -d research_restore /tmp/research.dump } | Select-Object TotalSeconds
TotalSeconds
------------
0,5392463
> docker compose exec postgres ls -lh /tmp/research.dump
-rw-r--r-- 1 root root 4.1M Oct 7 19:48 /tmp/research.dump
> docker compose exec postgres psql -U messenger -d research_restore
psql (18.6 (Debian 18.6-1.pgdg13+2))
Type "help" for help.
research_restore=# SELECT count(*) FROM messages;
count
--------
100000
(1 row)
research_restore=# SELECT md5(string_agg(id::text || chat_id::text || created_at::text || text, '' ORDER BY id)) AS full_hash FROM messages;
full_hash
----------------------------------
3b0b6c7f0769218c3d3d1a7b660f521c
(1 row)
research_restore=# SELECT md5(string_agg(id::text || text, '' ORDER BY created_at, id)) AS page_hash FROM (SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'big') AND (created_at, id) > ('2026-01-15 00:00+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50) p;
page_hash
----------------------------------
1b111bf87f61b52ef916f31037c4acb5
(1 row)
research_restore=# \q
> docker compose exec postgres rm /tmp/research.dump
+297
View File
@@ -0,0 +1,297 @@
C. (chat_id, id)
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'big') AND (created_at, id) > ('2026-01-15 00:00+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=810.77..810.89 rows=50 width=151) (actual time=11.161..11.167 rows=50.00 loops=1)
Buffers: shared hit=1730
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.012..0.024 rows=1.00 loops=1)
Filter: (title = 'big'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Sort (cost=806.19..806.68 rows=193 width=151) (actual time=11.159..11.162 rows=50.00 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: top-N heapsort Memory: 36kB
Buffers: shared hit=1730
-> Index Scan using idx_messages_chat_id on messages (cost=0.42..799.78 rows=193 width=151) (actual time=2.648..8.533 rows=39841.00 loops=1)
Index Cond: (chat_id = (InitPlan 1).col1)
Filter: (ROW(created_at, id) > ROW('2026-01-15 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid))
Rows Removed by Filter: 20159
Index Searches: 1
Buffers: shared hit=1730
Planning Time: 0.115 ms
Execution Time: 11.189 ms
(19 rows)
Time: 11.614 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'big') AND (created_at, id) > ('2026-01-15 00:00+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=810.77..810.89 rows=50 width=151) (actual time=13.602..13.609 rows=50.00 loops=1)
Buffers: shared hit=1730
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.034..0.044 rows=1.00 loops=1)
Filter: (title = 'big'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Sort (cost=806.19..806.68 rows=193 width=151) (actual time=13.601..13.604 rows=50.00 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: top-N heapsort Memory: 36kB
Buffers: shared hit=1730
-> Index Scan using idx_messages_chat_id on messages (cost=0.42..799.78 rows=193 width=151) (actual time=3.012..10.954 rows=39841.00 loops=1)
Index Cond: (chat_id = (InitPlan 1).col1)
Filter: (ROW(created_at, id) > ROW('2026-01-15 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid))
Rows Removed by Filter: 20159
Index Searches: 1
Buffers: shared hit=1730
Planning Time: 0.207 ms
Execution Time: 13.645 ms
(19 rows)
Time: 14.423 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'small-1') AND (created_at, id) > ('2026-01-01 00:30+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=819.50..819.63 rows=50 width=151) (actual time=0.140..0.148 rows=46.00 loops=1)
Buffers: shared hit=10
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.011..0.020 rows=1.00 loops=1)
Filter: (title = 'small-1'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Sort (cost=814.93..816.07 rows=456 width=151) (actual time=0.139..0.142 rows=46.00 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: quicksort Memory: 35kB
Buffers: shared hit=10
-> Index Scan using idx_messages_chat_id on messages (cost=0.42..799.78 rows=456 width=151) (actual time=0.039..0.047 rows=46.00 loops=1)
Index Cond: (chat_id = (InitPlan 1).col1)
Filter: (ROW(created_at, id) > ROW('2026-01-01 00:30:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid))
Rows Removed by Filter: 29
Index Searches: 1
Buffers: shared hit=10
Planning Time: 0.084 ms
Execution Time: 0.167 ms
(19 rows)
Time: 0.532 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'small-1') AND (created_at, id) > ('2026-01-01 00:30+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=819.50..819.63 rows=50 width=151) (actual time=0.126..0.131 rows=46.00 loops=1)
Buffers: shared hit=10
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.032..0.042 rows=1.00 loops=1)
Filter: (title = 'small-1'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Sort (cost=814.93..816.07 rows=456 width=151) (actual time=0.125..0.127 rows=46.00 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: quicksort Memory: 35kB
Buffers: shared hit=10
-> Index Scan using idx_messages_chat_id on messages (cost=0.42..799.78 rows=456 width=151) (actual time=0.075..0.086 rows=46.00 loops=1)
Index Cond: (chat_id = (InitPlan 1).col1)
Filter: (ROW(created_at, id) > ROW('2026-01-01 00:30:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid))
Rows Removed by Filter: 29
Index Searches: 1
Buffers: shared hit=10
Planning Time: 0.250 ms
Execution Time: 0.166 ms
(19 rows)
Time: 1.156 ms
B. (chat_id, created_at, id)
research=# DROP INDEX IF EXISTS idx_messages_chat_id;
DROP INDEX
Time: 3.644 ms
research=# CREATE INDEX idx_messages_chat_history ON messages (chat_id, created_at, id);
CREATE INDEX
Time: 69.022 ms
research=# ANALYZE messages;
ANALYZE
Time: 103.435 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'big') AND (created_at, id) > ('2026-01-15 00:00+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4.99..93.65 rows=50 width=151) (actual time=0.055..0.069 rows=50.00 loops=1)
Buffers: shared hit=4 read=4
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.009..0.019 rows=1.00 loops=1)
Filter: (title = 'big'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Index Scan using idx_messages_chat_history on messages (cost=0.42..340.85 rows=192 width=151) (actual time=0.054..0.065 rows=50.00 loops=1)
Index Cond: ((chat_id = (InitPlan 1).col1) AND (ROW(created_at, id) > ROW('2026-01-15 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Index Searches: 1
Buffers: shared hit=4 read=4
Planning:
Buffers: shared hit=21 read=1
Planning Time: 0.333 ms
Execution Time: 0.092 ms
(15 rows)
Time: 1.018 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'big') AND (created_at, id) > ('2026-01-15 00:00+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4.99..93.65 rows=50 width=151) (actual time=0.033..0.045 rows=50.00 loops=1)
Buffers: shared hit=8
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.011..0.020 rows=1.00 loops=1)
Filter: (title = 'big'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Index Scan using idx_messages_chat_history on messages (cost=0.42..340.85 rows=192 width=151) (actual time=0.032..0.041 rows=50.00 loops=1)
Index Cond: ((chat_id = (InitPlan 1).col1) AND (ROW(created_at, id) > ROW('2026-01-15 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Index Searches: 1
Buffers: shared hit=8
Planning Time: 0.106 ms
Execution Time: 0.061 ms
(13 rows)
Time: 0.464 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'small-1') AND (created_at, id) > ('2026-01-01 00:30+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4.99..88.31 rows=50 width=151) (actual time=0.139..0.152 rows=46.00 loops=1)
Buffers: shared hit=7 read=2
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.015..0.026 rows=1.00 loops=1)
Filter: (title = 'small-1'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Index Scan using idx_messages_chat_history on messages (cost=0.42..758.65 rows=455 width=151) (actual time=0.137..0.147 rows=46.00 loops=1)
Index Cond: ((chat_id = (InitPlan 1).col1) AND (ROW(created_at, id) > ROW('2026-01-01 00:30:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Index Searches: 1
Buffers: shared hit=7 read=2
Planning Time: 0.130 ms
Execution Time: 0.174 ms
(13 rows)
Time: 0.581 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'small-1') AND (created_at, id) > ('2026-01-01 00:30+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4.99..88.31 rows=50 width=151) (actual time=0.064..0.073 rows=46.00 loops=1)
Buffers: shared hit=9
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.030..0.039 rows=1.00 loops=1)
Filter: (title = 'small-1'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Index Scan using idx_messages_chat_history on messages (cost=0.42..758.65 rows=455 width=151) (actual time=0.063..0.069 rows=46.00 loops=1)
Index Cond: ((chat_id = (InitPlan 1).col1) AND (ROW(created_at, id) > ROW('2026-01-01 00:30:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Index Searches: 1
Buffers: shared hit=9
Planning Time: 0.208 ms
Execution Time: 0.100 ms
(13 rows)
Time: 0.808 ms
A. Only PK
research=# DROP INDEX IF EXISTS idx_messages_chat_history;
DROP INDEX
Time: 5.715 ms
research=# DROP INDEX IF EXISTS idx_messages_chat_id;
NOTICE: index "idx_messages_chat_id" does not exist, skipping
DROP INDEX
Time: 0.228 ms
research=# ANALYZE messages;
ANALYZE
Time: 102.311 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'big') AND (created_at, id) > ('2026-01-15 00:00+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4022.99..4023.11 rows=50 width=150) (actual time=10.619..10.625 rows=50.00 loops=1)
Buffers: shared hit=2264
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.007..0.019 rows=1.00 loops=1)
Filter: (title = 'big'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Sort (cost=4018.41..4018.89 rows=193 width=150) (actual time=10.616..10.619 rows=50.00 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: top-N heapsort Memory: 36kB
Buffers: shared hit=2264
-> Seq Scan on messages (cost=0.00..4012.00 rows=193 width=150) (actual time=1.644..8.293 rows=39841.00 loops=1)
Filter: ((chat_id = (InitPlan 1).col1) AND (ROW(created_at, id) > ROW('2026-01-15 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Rows Removed by Filter: 60159
Buffers: shared hit=2264
Planning:
Buffers: shared hit=20
Planning Time: 0.264 ms
Execution Time: 10.659 ms
(19 rows)
Time: 11.410 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'big') AND (created_at, id) > ('2026-01-15 00:00+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4022.99..4023.11 rows=50 width=150) (actual time=10.266..10.274 rows=50.00 loops=1)
Buffers: shared hit=2264
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.006..0.016 rows=1.00 loops=1)
Filter: (title = 'big'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Sort (cost=4018.41..4018.89 rows=193 width=150) (actual time=10.265..10.269 rows=50.00 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: top-N heapsort Memory: 36kB
Buffers: shared hit=2264
-> Seq Scan on messages (cost=0.00..4012.00 rows=193 width=150) (actual time=1.597..8.150 rows=39841.00 loops=1)
Filter: ((chat_id = (InitPlan 1).col1) AND (ROW(created_at, id) > ROW('2026-01-15 00:00:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Rows Removed by Filter: 60159
Buffers: shared hit=2264
Planning Time: 0.082 ms
Execution Time: 10.300 ms
(17 rows)
Time: 11.458 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'small-1') AND (created_at, id) > ('2026-01-01 00:30+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4031.69..4031.81 rows=50 width=150) (actual time=6.337..6.344 rows=46.00 loops=1)
Buffers: shared hit=2264
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.007..0.019 rows=1.00 loops=1)
Filter: (title = 'small-1'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Sort (cost=4027.11..4028.25 rows=455 width=150) (actual time=6.335..6.339 rows=46.00 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: quicksort Memory: 35kB
Buffers: shared hit=2264
-> Seq Scan on messages (cost=0.00..4012.00 rows=455 width=150) (actual time=4.345..6.255 rows=46.00 loops=1)
Filter: ((chat_id = (InitPlan 1).col1) AND (ROW(created_at, id) > ROW('2026-01-01 00:30:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Rows Removed by Filter: 99954
Buffers: shared hit=2264
Planning Time: 0.105 ms
Execution Time: 6.366 ms
(17 rows)
Time: 6.763 ms
research=# EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id = (SELECT id FROM chats WHERE title = 'small-1') AND (created_at, id) > ('2026-01-01 00:30+00', '00000000-0000-0000-0000-000000000000') ORDER BY created_at, id LIMIT 50;
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4031.69..4031.81 rows=50 width=150) (actual time=6.219..6.227 rows=46.00 loops=1)
Buffers: shared hit=2264
InitPlan 1
-> Seq Scan on chats (cost=0.00..4.58 rows=1 width=16) (actual time=0.009..0.021 rows=1.00 loops=1)
Filter: (title = 'small-1'::text)
Rows Removed by Filter: 205
Buffers: shared hit=2
-> Sort (cost=4027.11..4028.25 rows=455 width=150) (actual time=6.217..6.221 rows=46.00 loops=1)
Sort Key: messages.created_at, messages.id
Sort Method: quicksort Memory: 35kB
Buffers: shared hit=2264
-> Seq Scan on messages (cost=0.00..4012.00 rows=455 width=150) (actual time=4.517..6.205 rows=46.00 loops=1)
Filter: ((chat_id = (InitPlan 1).col1) AND (ROW(created_at, id) > ROW('2026-01-01 00:30:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
Rows Removed by Filter: 99954
Buffers: shared hit=2264
Planning Time: 0.110 ms
Execution Time: 6.248 ms
(17 rows)
Time: 6.727 ms
+168
View File
@@ -0,0 +1,168 @@
> docker compose exec postgres psql -U messenger -d postgres -c "CREATE DATABASE research;"
CREATE DATABASE
> docker compose run --rm --no-deps --entrypoint sh migrate -c 'URL=$(sed s,/messenger?,/research?, /run/secrets/database_url); goose -dir /migrations postgres $URL up'
Container mtusi2026lab2-migrate-run-37c6222942bf Creating
Container mtusi2026lab2-migrate-run-37c6222942bf Created
2026/10/07 19:30:06 OK 00001_init.sql (10.96ms)
2026/10/07 19:30:06 goose: successfully migrated database to version: 1
> docker compose exec postgres psql -U messenger -d research
psql (18.6 (Debian 18.6-1.pgdg13+2))
Type "help" for help.
research=# INSERT INTO users (id, username, display_name, password_hash) VALUES (uuidv7(), 'research_user', 'Research User', 'x');
INSERT 0 1
research=# INSERT INTO chats (id, title) SELECT uuidv7(), 'big';
INSERT 0 1
research=# INSERT INTO chats (id, title) SELECT uuidv7(), 'mid-' || g FROM generate_series(1, 5) g;
INSERT 0 5
research=# INSERT INTO chats (id, title) SELECT uuidv7(), 'small-' || g FROM generate_series(1, 200) g;
INSERT 0 200
research=# CREATE TABLE messages_seed AS
SELECT uuidv7() AS id,
c.id AS chat_id,
(SELECT id FROM users WHERE username = 'research_user') AS sender_id,
'message ' || n || ' ' || repeat(md5(random()::text), 1 + (n % 4)) AS text,
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 minute' AS created_at
FROM chats c
CROSS JOIN LATERAL generate_series(1, CASE split_part(c.title, '-', 1)
WHEN 'big' THEN 60000 WHEN 'mid' THEN 5000 ELSE 75 END) AS n;
SELECT 100000
A. Only PK
research=# SELECT 'VARIANT A' AS variant;
DROP INDEX IF EXISTS idx_messages_chat_history;
DROP INDEX IF EXISTS idx_messages_chat_id;
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
ANALYZE messages;
SELECT pg_size_pretty(pg_relation_size('messages')) AS table, indexrelid::regclass AS idx, pg_size_pretty(pg_relation_size(indexrelid)) AS size FROM pg_index WHERE indrelid = 'messages'::regclass;
variant
-----------
VARIANT A
(1 row)
Time: 0.345 ms
DROP INDEX
Time: 5.736 ms
NOTICE: index "idx_messages_chat_id" does not exist, skipping
DROP INDEX
Time: 0.153 ms
TRUNCATE TABLE
Time: 3.614 ms
INSERT 0 100000
Time: 989.859 ms
TRUNCATE TABLE
Time: 6.348 ms
INSERT 0 100000
Time: 976.844 ms
TRUNCATE TABLE
Time: 6.268 ms
INSERT 0 100000
Time: 977.896 ms
ANALYZE
Time: 103.989 ms
table | idx | size
-------+---------------+---------
18 MB | messages_pkey | 3104 kB
(1 row)
Time: 0.765 ms
B. (chat_id, created_at, id)
research=# SELECT 'VARIANT B' AS variant;
DROP INDEX IF EXISTS idx_messages_chat_id;
CREATE INDEX idx_messages_chat_history ON messages (chat_id, created_at, id);
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
ANALYZE messages;
SELECT pg_size_pretty(pg_relation_size('messages')) AS table, indexrelid::regclass AS idx, pg_size_pretty(pg_relation_size(indexrelid)) AS size FROM pg_index WHERE indrelid = 'messages'::regclass;
variant
-----------
VARIANT B
(1 row)
Time: 0.411 ms
NOTICE: index "idx_messages_chat_id" does not exist, skipping
DROP INDEX
Time: 0.144 ms
CREATE INDEX
Time: 165.646 ms
TRUNCATE TABLE
Time: 9.681 ms
INSERT 0 100000
Time: 1655.348 ms (00:01.655)
TRUNCATE TABLE
Time: 6.620 ms
INSERT 0 100000
Time: 1640.366 ms (00:01.640)
TRUNCATE TABLE
Time: 7.094 ms
INSERT 0 100000
Time: 1156.808 ms (00:01.157)
ANALYZE
Time: 92.376 ms
table | idx | size
-------+---------------------------+---------
18 MB | messages_pkey | 3104 kB
18 MB | idx_messages_chat_history | 5776 kB
(2 rows)
Time: 0.560 ms
C. (chat_id, id)
research=# SELECT 'VARIANT C' AS variant;
DROP INDEX IF EXISTS idx_messages_chat_history;
CREATE INDEX idx_messages_chat_id ON messages (chat_id, id);
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
TRUNCATE messages;
INSERT INTO messages SELECT id, chat_id, sender_id, text, created_at FROM messages_seed;
ANALYZE messages;
SELECT pg_size_pretty(pg_relation_size('messages')) AS table, indexrelid::regclass AS idx, pg_size_pretty(pg_relation_size(indexrelid)) AS size FROM pg_index WHERE indrelid = 'messages'::regclass;
variant
-----------
VARIANT C
(1 row)
Time: 0.362 ms
DROP INDEX
Time: 4.459 ms
CREATE INDEX
Time: 61.503 ms
TRUNCATE TABLE
Time: 6.046 ms
INSERT 0 100000
Time: 1222.658 ms (00:01.223)
TRUNCATE TABLE
Time: 6.482 ms
INSERT 0 100000
Time: 1181.280 ms (00:01.181)
TRUNCATE TABLE
Time: 6.286 ms
INSERT 0 100000
Time: 1185.066 ms (00:01.185)
ANALYZE
Time: 98.084 ms
table | idx | size
-------+----------------------+---------
18 MB | messages_pkey | 3104 kB
18 MB | idx_messages_chat_id | 4880 kB
(2 rows)
Time: 0.490 ms
+23
View File
@@ -0,0 +1,23 @@
module mtusi2026-messenger
go 1.26.0
require (
github.com/go-chi/chi/v5 v5.3.2
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.11.0
github.com/joho/godotenv v1.5.1
github.com/redis/go-redis/v9 v9.23.0
golang.org/x/crypto v0.57.0
)
require (
github.com/cespare/xxhash/v2 v2.3.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
github.com/jackc/puddle/v2 v2.2.2 // indirect
go.uber.org/atomic v1.12.0 // indirect
golang.org/x/sync v0.23.0 // indirect
golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.42.0 // indirect
)
+47
View File
@@ -0,0 +1,47 @@
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.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/go-chi/chi/v5 v5.3.2 h1:5YQkICvTCSZ25hoRsyJazN0scjzKGiu4VAUc7H1o1nY=
github.com/go-chi/chi/v5 v5.3.2/go.mod h1:R+tYY2hNuVUUjxoPtqUdgBqevM9s9njzkTLutVsOCto=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.11.0 h1:IzBBtyK9AHqf98cctWFifYSci2hgQR/cd56wB4p+ogg=
github.com/jackc/pgx/v5 v5.11.0/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/redis/go-redis/v9 v9.23.0 h1:/TTVdJa8BRNsybwwGGnmiYktHNlUXtbOQxlWpHBPL3s=
github.com/redis/go-redis/v9 v9.23.0/go.mod h1:EWP2UUk+XDaI1s5nQB5mablZN6vccXlmBQTyfnF87D0=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
go.uber.org/atomic v1.12.0 h1:BvcXdFKuviU4fTL/f+SxdQ5qJX/Jix8pAkgdUcb3XOE=
go.uber.org/atomic v1.12.0/go.mod h1:I6c4cg+6HCxRjfjSsYtApoFILnpc0CGUdGkXVqbYVNk=
go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk=
golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+123
View File
@@ -0,0 +1,123 @@
package app
import (
"context"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"github.com/joho/godotenv"
"mtusi2026-messenger/internal/config"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/logger"
"mtusi2026-messenger/internal/postgres"
"mtusi2026-messenger/internal/redis"
"mtusi2026-messenger/internal/service"
)
func Run() error {
if err := godotenv.Load(); err != nil && !os.IsNotExist(err) {
return err
}
cfg := config.Load()
log := logger.New(cfg.Logging.Level)
dbURL, err := cfg.Database.URL()
if err != nil {
log.Error("read database url", "error", err)
return err
}
pool, err := postgres.New(context.Background(), dbURL)
if err != nil {
log.Error("connect to database", "error", err)
return err
}
defer pool.Close()
queries := db.New(pool)
cacheURL, err := cfg.Redis.URL()
if err != nil {
log.Error("read redis url", "error", err)
return err
}
rdb, err := redis.New(context.Background(), log, cacheURL)
if err != nil {
log.Error("create redis client", "error", err)
return err
}
defer rdb.Close()
cleanupCtx, stopCleanup := context.WithCancel(context.Background())
cleanupDone := make(chan struct{})
go func() {
defer close(cleanupDone)
runSessionCleanup(cleanupCtx, log, queries, sessionCleanupInterval)
}()
defer func() {
stopCleanup()
<-cleanupDone
}()
authService := service.NewAuthService(queries, rdb, cfg.Server.SessionTTL, log)
userService := service.NewUserService(queries)
chatService := service.NewChatService(pool, queries)
messageService := service.NewMessageService(queries)
router := NewRouter(
log,
cfg.Server.MaxInflightRequests,
pool,
authService,
userService,
chatService,
messageService,
)
server := &http.Server{
Addr: cfg.Server.Host + ":" + cfg.Server.Port,
Handler: router,
}
serverErrors := make(chan error, 1)
go func() {
log.Info("server starting", "addr", server.Addr)
serverErrors <- server.ListenAndServe()
}()
signalCh := make(chan os.Signal, 1)
signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM)
defer signal.Stop(signalCh)
select {
case err := <-serverErrors:
if err == http.ErrServerClosed {
return nil
}
log.Error("server failed", "error", err)
return err
case sig := <-signalCh:
log.Info("shutdown signal received", "signal", sig.String())
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
log.Error("server shutdown failed", "error", err)
return err
}
log.Info("server stopped")
return nil
}
}
+36
View File
@@ -0,0 +1,36 @@
package app
import (
"context"
"log/slog"
"time"
)
const sessionCleanupInterval = time.Hour
type sessionCleaner interface {
DeleteExpiredSessions(ctx context.Context) (int64, error)
}
func runSessionCleanup(ctx context.Context, log *slog.Logger, q sessionCleaner, interval time.Duration) {
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
n, err := q.DeleteExpiredSessions(ctx)
if err != nil {
if ctx.Err() == nil {
log.Error("delete expired sessions", "error", err)
}
continue
}
if n > 0 {
log.Info("expired sessions deleted", "count", n)
}
}
}
}
+46
View File
@@ -0,0 +1,46 @@
package app
import (
"context"
"fmt"
"net/http"
"os"
"time"
"mtusi2026-messenger/internal/config"
"github.com/joho/godotenv"
)
func Healthcheck() int {
if err := godotenv.Load(); err != nil && !os.IsNotExist(err) {
fmt.Fprintln(os.Stderr, "healthcheck: load env:", err)
return 1
}
cfg := config.Load()
url := fmt.Sprintf("http://localhost:%s/health/ready", cfg.Server.Port)
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
if err != nil {
fmt.Fprintln(os.Stderr, "healthcheck: build request:", err)
return 1
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Fprintln(os.Stderr, "healthcheck: request failed:", err)
return 1
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
fmt.Fprintln(os.Stderr, "healthcheck: unexpected status", resp.StatusCode)
return 1
}
return 0
}
+62
View File
@@ -0,0 +1,62 @@
package app
import (
"log/slog"
"net/http"
"time"
"github.com/go-chi/chi/v5"
"mtusi2026-messenger/internal/handler"
"mtusi2026-messenger/internal/middleware"
"mtusi2026-messenger/internal/service"
)
func NewRouter(
log *slog.Logger,
maxInflightRequests int,
db handler.Pinger,
authService *service.AuthService,
userService *service.UserService,
chatService *service.ChatService,
messageService *service.MessageService,
) http.Handler {
router := chi.NewRouter()
healthHandler := handler.NewHealthHandler(log, db)
authHandler := handler.NewAuthHandler(authService)
userHandler := handler.NewUserHandler(userService)
chatHandler := handler.NewChatHandler(chatService)
messageHandler := handler.NewMessageHandler(messageService)
router.Use(middleware.RequestTimeout(5 * time.Second))
router.Use(middleware.RequestID)
router.Use(middleware.Logging(log))
router.Use(middleware.ConcurrencyLimit(maxInflightRequests))
router.Get("/health/live", healthHandler.Live)
router.Get("/health/ready", healthHandler.Ready)
router.Post("/api/v1/users", userHandler.Create)
router.Post("/api/v1/auth/sessions", authHandler.CreateSession)
router.Delete("/api/v1/auth/sessions/current", authHandler.RevokeSession)
router.Group(func(r chi.Router) {
r.Use(middleware.Auth(authService))
r.Get("/api/v1/users/me", userHandler.Me)
r.Post("/api/v1/chats", chatHandler.Create)
r.Get("/api/v1/chats", chatHandler.List)
r.Get("/api/v1/chats/{chat_id}", chatHandler.Get)
r.Post("/api/v1/chats/{chat_id}/messages", messageHandler.Create)
r.Get("/api/v1/chats/{chat_id}/messages", messageHandler.List)
})
router.Handle("/swagger/*", http.StripPrefix("/swagger/", http.FileServer(http.Dir("web/swagger"))))
router.Handle("/contracts/*", http.StripPrefix("/contracts/", http.FileServer(http.Dir("contracts"))))
return router
}
+141
View File
@@ -0,0 +1,141 @@
package config
import (
"fmt"
"log"
"log/slog"
"os"
"strconv"
"strings"
"time"
)
type Config struct {
Server ServerConfig
Logging LoggingConfig
Database DatabaseConfig
Redis RedisConfig
}
type ServerConfig struct {
Host string
Port string
MaxInflightRequests int
SessionTTL time.Duration
}
type LoggingConfig struct {
Level slog.Level
}
type DatabaseConfig struct {
URLFile string
}
func (c DatabaseConfig) URL() (string, error) {
return readSecretFile(c.URLFile)
}
type RedisConfig struct {
URLFile string
}
func (c RedisConfig) URL() (string, error) {
return readSecretFile(c.URLFile)
}
func Load() Config {
return Config{
Server: ServerConfig{
Host: getEnv("APP_HOST", "0.0.0.0"),
Port: getEnv("APP_PORT", "8080"),
MaxInflightRequests: getEnvNonNegativeInt("MAX_INFLIGHT_REQUESTS", 0),
SessionTTL: time.Duration(getEnvPositiveInt("SESSION_TTL_SECONDS", 3600)) * time.Second,
},
Logging: LoggingConfig{
Level: getEnvLogLevel("LOG_LEVEL", slog.LevelInfo),
},
Database: DatabaseConfig{
URLFile: getEnv("DATABASE_URL_FILE", "/run/secrets/database_url"),
},
Redis: RedisConfig{
URLFile: getEnv("CACHE_URL_FILE", "/run/secrets/cache_url"),
},
}
}
func getEnv(key, def string) string {
value := os.Getenv(key)
if value == "" {
return def
}
return value
}
func getEnvNonNegativeInt(key string, def int) int {
v := os.Getenv(key)
if v == "" {
return def
}
value, err := strconv.Atoi(v)
if err != nil || value < 0 {
log.Printf("invalid non-negative int for %s=%q, using default %d", key, v, def)
return def
}
return value
}
func getEnvPositiveInt(key string, def int) int {
v := os.Getenv(key)
if v == "" {
return def
}
value, err := strconv.Atoi(v)
if err != nil || value <= 0 {
log.Printf("invalid positive int for %s=%q, using default %d", key, v, def)
return def
}
return value
}
func getEnvLogLevel(key string, def slog.Level) slog.Level {
v := os.Getenv(key)
switch v {
case "DEBUG":
return slog.LevelDebug
case "INFO":
return slog.LevelInfo
case "WARN":
return slog.LevelWarn
case "ERROR":
return slog.LevelError
case "":
return def
default:
log.Printf("invalid log level for %s=%q, using default %s", key, v, def)
return def
}
}
func readSecretFile(path string) (string, error) {
b, err := os.ReadFile(path)
if err != nil {
return "", fmt.Errorf("read secret file %s: %w", path, err)
}
value := strings.TrimSpace(string(b))
if value == "" {
return "", fmt.Errorf("secret file %s is empty", path)
}
return value, nil
}
+51
View File
@@ -0,0 +1,51 @@
package credentials
import (
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"errors"
"golang.org/x/crypto/bcrypt"
)
const tokenSize = 32
var ErrPasswordMismatch = errors.New("password mismatch")
func prehash(plain string) []byte {
sum := sha256.Sum256([]byte(plain))
return []byte(base64.StdEncoding.EncodeToString(sum[:]))
}
func HashPassword(plain string) (string, error) {
hash, err := bcrypt.GenerateFromPassword(prehash(plain), bcrypt.DefaultCost)
if err != nil {
return "", err
}
return string(hash), nil
}
func VerifyPassword(hash, plain string) error {
err := bcrypt.CompareHashAndPassword([]byte(hash), prehash(plain))
if errors.Is(err, bcrypt.ErrMismatchedHashAndPassword) {
return ErrPasswordMismatch
}
return err
}
func NewToken() string {
raw := make([]byte, tokenSize)
_, _ = rand.Read(raw) // never returns an error since Go 1.24
return base64.RawURLEncoding.EncodeToString(raw)
}
func HashToken(token string) string {
sum := sha256.Sum256([]byte(token))
return hex.EncodeToString(sum[:])
}
+232
View File
@@ -0,0 +1,232 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: chats.sql
package db
import (
"context"
"time"
"github.com/google/uuid"
)
const addChatMembers = `-- name: AddChatMembers :exec
INSERT INTO chat_members (
chat_id,
user_id
)
SELECT
$1::uuid,
unnest($2::uuid[])
`
type AddChatMembersParams struct {
ChatID uuid.UUID
UserIds []uuid.UUID
}
func (q *Queries) AddChatMembers(ctx context.Context, arg AddChatMembersParams) error {
_, err := q.db.Exec(ctx, addChatMembers, arg.ChatID, arg.UserIds)
return err
}
const createChat = `-- name: CreateChat :one
INSERT INTO chats (
id,
title
) VALUES (
$1,
$2
)
RETURNING id, title, created_at
`
type CreateChatParams struct {
ID uuid.UUID
Title string
}
func (q *Queries) CreateChat(ctx context.Context, arg CreateChatParams) (Chat, error) {
row := q.db.QueryRow(ctx, createChat, arg.ID, arg.Title)
var i Chat
err := row.Scan(&i.ID, &i.Title, &i.CreatedAt)
return i, err
}
const getChat = `-- name: GetChat :one
SELECT
c.id, c.title, c.created_at,
ARRAY(
SELECT cm.user_id FROM chat_members cm
WHERE cm.chat_id = c.id
ORDER BY cm.user_id
)::uuid[] AS member_ids
FROM chats c
WHERE c.id = $1
AND EXISTS (
SELECT 1 FROM chat_members m
WHERE m.chat_id = c.id
AND m.user_id = $2
)
`
type GetChatParams struct {
ID uuid.UUID
UserID uuid.UUID
}
type GetChatRow struct {
ID uuid.UUID
Title string
CreatedAt time.Time
MemberIds []uuid.UUID
}
func (q *Queries) GetChat(ctx context.Context, arg GetChatParams) (GetChatRow, error) {
row := q.db.QueryRow(ctx, getChat, arg.ID, arg.UserID)
var i GetChatRow
err := row.Scan(
&i.ID,
&i.Title,
&i.CreatedAt,
&i.MemberIds,
)
return i, err
}
const isChatMember = `-- name: IsChatMember :one
SELECT EXISTS (
SELECT 1 FROM chat_members
WHERE chat_id = $1
AND user_id = $2
)
`
type IsChatMemberParams struct {
ChatID uuid.UUID
UserID uuid.UUID
}
func (q *Queries) IsChatMember(ctx context.Context, arg IsChatMemberParams) (bool, error) {
row := q.db.QueryRow(ctx, isChatMember, arg.ChatID, arg.UserID)
var exists bool
err := row.Scan(&exists)
return exists, err
}
const listChatsAfter = `-- name: ListChatsAfter :many
SELECT
c.id, c.title, c.created_at,
ARRAY(
SELECT cm.user_id FROM chat_members cm
WHERE cm.chat_id = c.id
ORDER BY cm.user_id
)::uuid[] AS member_ids
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = $1
AND (c.created_at, c.id) > (
$2::timestamptz,
$3::uuid
)
ORDER BY c.created_at, c.id
LIMIT $4
`
type ListChatsAfterParams struct {
UserID uuid.UUID
AfterCreatedAt time.Time
AfterID uuid.UUID
Lim int32
}
type ListChatsAfterRow struct {
ID uuid.UUID
Title string
CreatedAt time.Time
MemberIds []uuid.UUID
}
func (q *Queries) ListChatsAfter(ctx context.Context, arg ListChatsAfterParams) ([]ListChatsAfterRow, error) {
rows, err := q.db.Query(ctx, listChatsAfter,
arg.UserID,
arg.AfterCreatedAt,
arg.AfterID,
arg.Lim,
)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ListChatsAfterRow{}
for rows.Next() {
var i ListChatsAfterRow
if err := rows.Scan(
&i.ID,
&i.Title,
&i.CreatedAt,
&i.MemberIds,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listChatsFirstPage = `-- name: ListChatsFirstPage :many
SELECT
c.id, c.title, c.created_at,
ARRAY(
SELECT cm.user_id FROM chat_members cm
WHERE cm.chat_id = c.id
ORDER BY cm.user_id
)::uuid[] AS member_ids
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = $1
ORDER BY c.created_at, c.id
LIMIT $2
`
type ListChatsFirstPageParams struct {
UserID uuid.UUID
Lim int32
}
type ListChatsFirstPageRow struct {
ID uuid.UUID
Title string
CreatedAt time.Time
MemberIds []uuid.UUID
}
func (q *Queries) ListChatsFirstPage(ctx context.Context, arg ListChatsFirstPageParams) ([]ListChatsFirstPageRow, error) {
rows, err := q.db.Query(ctx, listChatsFirstPage, arg.UserID, arg.Lim)
if err != nil {
return nil, err
}
defer rows.Close()
items := []ListChatsFirstPageRow{}
for rows.Next() {
var i ListChatsFirstPageRow
if err := rows.Scan(
&i.ID,
&i.Title,
&i.CreatedAt,
&i.MemberIds,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
+32
View File
@@ -0,0 +1,32 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
package db
import (
"context"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
type DBTX interface {
Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
Query(context.Context, string, ...interface{}) (pgx.Rows, error)
QueryRow(context.Context, string, ...interface{}) pgx.Row
}
func New(db DBTX) *Queries {
return &Queries{db: db}
}
type Queries struct {
db DBTX
}
func (q *Queries) WithTx(tx pgx.Tx) *Queries {
return &Queries{
db: tx,
}
}
+145
View File
@@ -0,0 +1,145 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: messages.sql
package db
import (
"context"
"time"
"github.com/google/uuid"
)
const createMessage = `-- name: CreateMessage :one
INSERT INTO messages (
id,
chat_id,
sender_id,
text
)
SELECT
$1::uuid,
$2::uuid,
$3::uuid,
$4::text
WHERE EXISTS (
SELECT 1 FROM chat_members
WHERE chat_id = $2
AND user_id = $3
)
RETURNING id, chat_id, sender_id, text, created_at
`
type CreateMessageParams struct {
ID uuid.UUID
ChatID uuid.UUID
SenderID uuid.UUID
Text string
}
func (q *Queries) CreateMessage(ctx context.Context, arg CreateMessageParams) (Message, error) {
row := q.db.QueryRow(ctx, createMessage,
arg.ID,
arg.ChatID,
arg.SenderID,
arg.Text,
)
var i Message
err := row.Scan(
&i.ID,
&i.ChatID,
&i.SenderID,
&i.Text,
&i.CreatedAt,
)
return i, err
}
const listMessagesAfter = `-- name: ListMessagesAfter :many
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
`
type ListMessagesAfterParams struct {
ChatID uuid.UUID
AfterCreatedAt time.Time
AfterID uuid.UUID
Lim int32
}
func (q *Queries) ListMessagesAfter(ctx context.Context, arg ListMessagesAfterParams) ([]Message, error) {
rows, err := q.db.Query(ctx, listMessagesAfter,
arg.ChatID,
arg.AfterCreatedAt,
arg.AfterID,
arg.Lim,
)
if err != nil {
return nil, err
}
defer rows.Close()
items := []Message{}
for rows.Next() {
var i Message
if err := rows.Scan(
&i.ID,
&i.ChatID,
&i.SenderID,
&i.Text,
&i.CreatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
const listMessagesFirstPage = `-- name: ListMessagesFirstPage :many
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1
ORDER BY created_at, id
LIMIT $2
`
type ListMessagesFirstPageParams struct {
ChatID uuid.UUID
Lim int32
}
func (q *Queries) ListMessagesFirstPage(ctx context.Context, arg ListMessagesFirstPageParams) ([]Message, error) {
rows, err := q.db.Query(ctx, listMessagesFirstPage, arg.ChatID, arg.Lim)
if err != nil {
return nil, err
}
defer rows.Close()
items := []Message{}
for rows.Next() {
var i Message
if err := rows.Scan(
&i.ID,
&i.ChatID,
&i.SenderID,
&i.Text,
&i.CreatedAt,
); err != nil {
return nil, err
}
items = append(items, i)
}
if err := rows.Err(); err != nil {
return nil, err
}
return items, nil
}
+45
View File
@@ -0,0 +1,45 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
package db
import (
"time"
"github.com/google/uuid"
)
type Chat struct {
ID uuid.UUID
Title string
CreatedAt time.Time
}
type ChatMember struct {
ChatID uuid.UUID
UserID uuid.UUID
}
type Message struct {
ID uuid.UUID
ChatID uuid.UUID
SenderID uuid.UUID
Text string
CreatedAt time.Time
}
type Session struct {
TokenHash string
UserID uuid.UUID
CreatedAt time.Time
ExpiresAt time.Time
}
type User struct {
ID uuid.UUID
Username string
DisplayName string
PasswordHash string
CreatedAt time.Time
}
+81
View File
@@ -0,0 +1,81 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: sessions.sql
package db
import (
"context"
"time"
"github.com/google/uuid"
)
const createSession = `-- name: CreateSession :exec
INSERT INTO sessions (
token_hash,
user_id,
expires_at
) VALUES (
$1,
$2,
$3
)
`
type CreateSessionParams struct {
TokenHash string
UserID uuid.UUID
ExpiresAt time.Time
}
func (q *Queries) CreateSession(ctx context.Context, arg CreateSessionParams) error {
_, err := q.db.Exec(ctx, createSession, arg.TokenHash, arg.UserID, arg.ExpiresAt)
return err
}
const deleteExpiredSessions = `-- name: DeleteExpiredSessions :execrows
DELETE FROM sessions
WHERE expires_at <= now()
`
func (q *Queries) DeleteExpiredSessions(ctx context.Context) (int64, error) {
result, err := q.db.Exec(ctx, deleteExpiredSessions)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const deleteSession = `-- name: DeleteSession :execrows
DELETE FROM sessions
WHERE token_hash = $1
AND expires_at > now()
`
func (q *Queries) DeleteSession(ctx context.Context, tokenHash string) (int64, error) {
result, err := q.db.Exec(ctx, deleteSession, tokenHash)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const getActiveSession = `-- name: GetActiveSession :one
SELECT user_id, expires_at FROM sessions
WHERE token_hash = $1
AND expires_at > now()
`
type GetActiveSessionRow struct {
UserID uuid.UUID
ExpiresAt time.Time
}
func (q *Queries) GetActiveSession(ctx context.Context, tokenHash string) (GetActiveSessionRow, error) {
row := q.db.QueryRow(ctx, getActiveSession, tokenHash)
var i GetActiveSessionRow
err := row.Scan(&i.UserID, &i.ExpiresAt)
return i, err
}
+101
View File
@@ -0,0 +1,101 @@
// Code generated by sqlc. DO NOT EDIT.
// versions:
// sqlc v1.31.1
// source: users.sql
package db
import (
"context"
"time"
"github.com/google/uuid"
)
const createUser = `-- name: CreateUser :one
INSERT INTO users (
id,
username,
display_name,
password_hash
) VALUES (
$1,
$2,
$3,
$4
)
RETURNING id, username, display_name, created_at
`
type CreateUserParams struct {
ID uuid.UUID
Username string
DisplayName string
PasswordHash string
}
type CreateUserRow struct {
ID uuid.UUID
Username string
DisplayName string
CreatedAt time.Time
}
func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (CreateUserRow, error) {
row := q.db.QueryRow(ctx, createUser,
arg.ID,
arg.Username,
arg.DisplayName,
arg.PasswordHash,
)
var i CreateUserRow
err := row.Scan(
&i.ID,
&i.Username,
&i.DisplayName,
&i.CreatedAt,
)
return i, err
}
const getUser = `-- name: GetUser :one
SELECT id, username, display_name, created_at FROM users
WHERE id = $1
`
type GetUserRow struct {
ID uuid.UUID
Username string
DisplayName string
CreatedAt time.Time
}
func (q *Queries) GetUser(ctx context.Context, id uuid.UUID) (GetUserRow, error) {
row := q.db.QueryRow(ctx, getUser, id)
var i GetUserRow
err := row.Scan(
&i.ID,
&i.Username,
&i.DisplayName,
&i.CreatedAt,
)
return i, err
}
const getUserByUsername = `-- name: GetUserByUsername :one
SELECT id, username, display_name, password_hash, created_at FROM users
WHERE username = $1
`
func (q *Queries) GetUserByUsername(ctx context.Context, username string) (User, error) {
row := q.db.QueryRow(ctx, getUserByUsername, username)
var i User
err := row.Scan(
&i.ID,
&i.Username,
&i.DisplayName,
&i.PasswordHash,
&i.CreatedAt,
)
return i, err
}
+50
View File
@@ -0,0 +1,50 @@
package dto
import (
"mtusi2026-messenger/internal/model"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
)
type CreateChatRequest struct {
Title string `json:"title"`
MemberIDs []uuid.UUID `json:"member_ids"`
}
type ChatResponse struct {
ID uuid.UUID `json:"id"`
Title string `json:"title"`
MemberIDs []uuid.UUID `json:"member_ids"`
CreatedAt time.Time `json:"created_at"`
}
type ChatPageResponse struct {
Items []ChatResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func (r CreateChatRequest) Validate() bool {
if strings.TrimSpace(r.Title) == "" ||
strings.ContainsRune(r.Title, 0) ||
utf8.RuneCountInString(r.Title) > 100 {
return false
}
if len(r.MemberIDs) < 1 || len(r.MemberIDs) > 100 {
return false
}
return true
}
func ToChatResponse(c model.Chat) ChatResponse {
return ChatResponse{
ID: c.ID,
Title: c.Title,
MemberIDs: c.MemberIDs,
CreatedAt: c.CreatedAt,
}
}
+25
View File
@@ -0,0 +1,25 @@
package dto
type ErrorCode string
const (
ErrorCodeInvalidRequest ErrorCode = "invalid_request"
ErrorCodeUnauthorized ErrorCode = "unauthorized"
ErrorCodeNotFound ErrorCode = "not_found"
ErrorCodeConflict ErrorCode = "conflict"
ErrorCodePayloadTooLarge ErrorCode = "payload_too_large"
ErrorCodeUnsupportedMediaType ErrorCode = "unsupported_media_type"
ErrorCodeRateLimited ErrorCode = "rate_limited"
ErrorCodeUnavailable ErrorCode = "unavailable"
ErrorCodeInternalError ErrorCode = "internal_error"
)
type ErrorResponse struct {
Error Error `json:"error"`
}
type Error struct {
Code ErrorCode `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
+5
View File
@@ -0,0 +1,5 @@
package dto
type HealthResponse struct {
Status string `json:"status"`
}
+47
View File
@@ -0,0 +1,47 @@
package dto
import (
"mtusi2026-messenger/internal/model"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
)
type CreateMessageRequest struct {
Text string `json:"text"`
}
type MessageResponse struct {
ID uuid.UUID `json:"id"`
ChatID uuid.UUID `json:"chat_id"`
SenderID uuid.UUID `json:"sender_id"`
Text string `json:"text"`
CreatedAt time.Time `json:"created_at"`
}
type MessagePageResponse struct {
Items []MessageResponse `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func (r CreateMessageRequest) Validate() bool {
if strings.TrimSpace(r.Text) == "" ||
strings.ContainsRune(r.Text, 0) ||
utf8.RuneCountInString(r.Text) > 4000 {
return false
}
return true
}
func ToMessageResponse(m model.Message) MessageResponse {
return MessageResponse{
ID: m.ID,
ChatID: m.ChatID,
SenderID: m.SenderID,
Text: m.Text,
CreatedAt: m.CreatedAt,
}
}
+10
View File
@@ -0,0 +1,10 @@
package dto
import "time"
type SessionResponse struct {
Token string `json:"token"`
TokenType string `json:"token_type"`
ExpiresAt time.Time `json:"expires_at"`
User UserResponse `json:"user"`
}
+44
View File
@@ -0,0 +1,44 @@
package dto
import (
"regexp"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
)
var usernamePattern = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
type CreateUserRequest struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
Password string `json:"password"`
}
type UserResponse struct {
ID uuid.UUID `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt time.Time `json:"created_at"`
}
func (r CreateUserRequest) Validate() bool {
if !usernamePattern.MatchString(r.Username) {
return false
}
displayNameLength := utf8.RuneCountInString(r.DisplayName)
if strings.TrimSpace(r.DisplayName) == "" ||
displayNameLength > 100 ||
strings.ContainsRune(r.DisplayName, 0) {
return false
}
if n := utf8.RuneCountInString(r.Password); n < 12 || n > 128 {
return false
}
return true
}
+73
View File
@@ -0,0 +1,73 @@
package handler
import (
"errors"
"net/http"
"mtusi2026-messenger/internal/dto"
"mtusi2026-messenger/internal/httpx"
"mtusi2026-messenger/internal/middleware"
"mtusi2026-messenger/internal/service"
)
type AuthHandler struct {
service *service.AuthService
}
func NewAuthHandler(s *service.AuthService) *AuthHandler {
return &AuthHandler{service: s}
}
func (h *AuthHandler) CreateSession(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
username, plain, ok := r.BasicAuth()
if !ok {
httpx.WriteUnauthorized(w, httpx.BasicChallenge, requestID)
return
}
session, err := h.service.Login(r.Context(), username, plain)
if errors.Is(err, service.ErrInvalidCredentials) {
httpx.WriteUnauthorized(w, httpx.BasicChallenge, requestID)
return
}
if err != nil {
httpx.WriteInternalError(w, requestID, err)
return
}
httpx.WriteJSON(w, http.StatusCreated, dto.SessionResponse{
Token: session.Token,
TokenType: "Bearer",
ExpiresAt: session.ExpiresAt,
User: dto.UserResponse{
ID: session.User.ID,
Username: session.User.Username,
DisplayName: session.User.DisplayName,
CreatedAt: session.User.CreatedAt,
},
})
}
func (h *AuthHandler) RevokeSession(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
token, ok := httpx.BearerToken(r)
if !ok {
httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID)
return
}
err := h.service.Logout(r.Context(), token)
if errors.Is(err, service.ErrUnauthorized) {
httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID)
return
}
if err != nil {
httpx.WriteInternalError(w, requestID, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
+150
View File
@@ -0,0 +1,150 @@
package handler
import (
"errors"
"net/http"
"github.com/go-chi/chi/v5"
"github.com/google/uuid"
"mtusi2026-messenger/internal/dto"
"mtusi2026-messenger/internal/httpx"
"mtusi2026-messenger/internal/middleware"
"mtusi2026-messenger/internal/service"
)
type ChatHandler struct {
service *service.ChatService
}
func NewChatHandler(service *service.ChatService) *ChatHandler {
return &ChatHandler{service: service}
}
func (h *ChatHandler) Create(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
userID := middleware.GetUserID(r.Context())
var req dto.CreateChatRequest
if !httpx.DecodeJSONBody(w, r, requestID, &req) {
return
}
if !req.Validate() {
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"invalid request body",
requestID,
)
return
}
chat, err := h.service.Create(r.Context(), userID, req.Title, req.MemberIDs)
switch {
case errors.Is(err, service.ErrNotChatMember):
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"caller must be a member of member_ids",
requestID,
)
return
case errors.Is(err, service.ErrDuplicateMember):
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"member_ids contains duplicates",
requestID,
)
return
case errors.Is(err, service.ErrUnknownMember):
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"member_ids contains unknown user",
requestID,
)
return
case err != nil:
httpx.WriteInternalError(w, requestID, err)
return
}
httpx.WriteJSON(w, http.StatusCreated, dto.ToChatResponse(chat))
}
func (h *ChatHandler) Get(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
userID := middleware.GetUserID(r.Context())
chatID, err := uuid.Parse(chi.URLParam(r, "chat_id"))
if err != nil {
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"invalid chat_id",
requestID,
)
return
}
chat, err := h.service.Get(r.Context(), userID, chatID)
switch {
case errors.Is(err, service.ErrChatNotFound):
httpx.WriteError(
w,
http.StatusNotFound,
dto.ErrorCodeNotFound,
"chat not found",
requestID,
)
return
case err != nil:
httpx.WriteInternalError(w, requestID, err)
return
}
httpx.WriteJSON(w, http.StatusOK, dto.ToChatResponse(chat))
}
func (h *ChatHandler) List(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
userID := middleware.GetUserID(r.Context())
limit, cursor, ok := httpx.ParsePagination(w, r, requestID)
if !ok {
return
}
chats, nextCursor, err := h.service.List(r.Context(), userID, limit, cursor)
switch {
case errors.Is(err, service.ErrInvalidCursor):
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"invalid cursor",
requestID,
)
return
case err != nil:
httpx.WriteInternalError(w, requestID, err)
return
}
items := make([]dto.ChatResponse, 0, len(chats))
for _, c := range chats {
items = append(items, dto.ToChatResponse(c))
}
httpx.WriteJSON(w, http.StatusOK, dto.ChatPageResponse{
Items: items,
NextCursor: nextCursor,
})
}
+60
View File
@@ -0,0 +1,60 @@
package handler
import (
"context"
"encoding/json"
"log/slog"
"net/http"
"time"
"mtusi2026-messenger/internal/dto"
"mtusi2026-messenger/internal/httpx"
)
const readyPingTimeout = 2 * time.Second
type Pinger interface {
Ping(ctx context.Context) error
}
type HealthHandler struct {
log *slog.Logger
db Pinger
}
func NewHealthHandler(log *slog.Logger, db Pinger) *HealthHandler {
return &HealthHandler{log: log, db: db}
}
func (h *HealthHandler) Live(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_ = json.NewEncoder(w).Encode(dto.HealthResponse{
Status: "ok",
})
}
func (h *HealthHandler) Ready(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), readyPingTimeout)
defer cancel()
if err := h.db.Ping(ctx); err != nil {
h.log.ErrorContext(r.Context(), "readiness check failed", "error", err)
httpx.WriteError(
w,
http.StatusServiceUnavailable,
dto.ErrorCodeUnavailable,
"service unavailable",
w.Header().Get("X-Request-Id"),
)
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_ = json.NewEncoder(w).Encode(dto.HealthResponse{
Status: "ok",
})
}
+130
View File
@@ -0,0 +1,130 @@
package handler
import (
"errors"
"net/http"
"github.com/go-chi/chi/v5"
"github.com/google/uuid"
"mtusi2026-messenger/internal/dto"
"mtusi2026-messenger/internal/httpx"
"mtusi2026-messenger/internal/middleware"
"mtusi2026-messenger/internal/service"
)
type MessageHandler struct {
service *service.MessageService
}
func NewMessageHandler(service *service.MessageService) *MessageHandler {
return &MessageHandler{service: service}
}
func (h *MessageHandler) Create(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
userID := middleware.GetUserID(r.Context())
chatID, err := uuid.Parse(chi.URLParam(r, "chat_id"))
if err != nil {
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"invalid chat_id",
requestID,
)
return
}
var req dto.CreateMessageRequest
if !httpx.DecodeJSONBody(w, r, requestID, &req) {
return
}
if !req.Validate() {
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"invalid request body",
requestID,
)
return
}
message, err := h.service.Create(r.Context(), userID, chatID, req.Text)
switch {
case errors.Is(err, service.ErrMessageChatNotFound):
httpx.WriteError(
w,
http.StatusNotFound,
dto.ErrorCodeNotFound,
"chat not found",
requestID,
)
return
case err != nil:
httpx.WriteInternalError(w, requestID, err)
return
}
httpx.WriteJSON(w, http.StatusCreated, dto.ToMessageResponse(message))
}
func (h *MessageHandler) List(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
userID := middleware.GetUserID(r.Context())
chatID, err := uuid.Parse(chi.URLParam(r, "chat_id"))
if err != nil {
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"invalid chat_id",
requestID,
)
return
}
limit, cursor, ok := httpx.ParsePagination(w, r, requestID)
if !ok {
return
}
messages, nextCursor, err := h.service.List(r.Context(), userID, chatID, limit, cursor)
switch {
case errors.Is(err, service.ErrMessageChatNotFound):
httpx.WriteError(
w,
http.StatusNotFound,
dto.ErrorCodeNotFound,
"chat not found",
requestID,
)
return
case errors.Is(err, service.ErrInvalidCursor):
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"invalid cursor",
requestID,
)
return
case err != nil:
httpx.WriteInternalError(w, requestID, err)
return
}
items := make([]dto.MessageResponse, 0, len(messages))
for _, m := range messages {
items = append(items, dto.ToMessageResponse(m))
}
httpx.WriteJSON(w, http.StatusOK, dto.MessagePageResponse{
Items: items,
NextCursor: nextCursor,
})
}
+95
View File
@@ -0,0 +1,95 @@
package handler
import (
"errors"
"net/http"
"mtusi2026-messenger/internal/dto"
"mtusi2026-messenger/internal/httpx"
"mtusi2026-messenger/internal/middleware"
"mtusi2026-messenger/internal/service"
)
type UserHandler struct {
service *service.UserService
}
func NewUserHandler(service *service.UserService) *UserHandler {
return &UserHandler{service: service}
}
func (h *UserHandler) Create(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
var req dto.CreateUserRequest
if !httpx.DecodeJSONBody(w, r, requestID, &req) {
return
}
if !req.Validate() {
httpx.WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"invalid request body",
requestID,
)
return
}
user, err := h.service.Create(
r.Context(),
req.Username,
req.DisplayName,
req.Password,
)
if errors.Is(err, service.ErrUsernameTaken) {
httpx.WriteError(
w,
http.StatusConflict,
dto.ErrorCodeConflict,
"username already taken",
requestID,
)
return
}
if err != nil {
httpx.WriteInternalError(w, requestID, err)
return
}
httpx.WriteJSON(w, http.StatusCreated, dto.UserResponse{
ID: user.ID,
Username: user.Username,
DisplayName: user.DisplayName,
CreatedAt: user.CreatedAt,
})
}
func (h *UserHandler) Me(w http.ResponseWriter, r *http.Request) {
requestID := middleware.GetRequestID(r.Context())
userID := middleware.GetUserID(r.Context())
user, err := h.service.GetByID(r.Context(), userID)
if errors.Is(err, service.ErrUserNotFound) {
httpx.WriteError(
w,
http.StatusNotFound,
dto.ErrorCodeNotFound,
"user not found",
requestID,
)
return
}
if err != nil {
httpx.WriteInternalError(w, requestID, err)
return
}
httpx.WriteJSON(w, http.StatusOK, dto.UserResponse{
ID: user.ID,
Username: user.Username,
DisplayName: user.DisplayName,
CreatedAt: user.CreatedAt,
})
}
+37
View File
@@ -0,0 +1,37 @@
package httpx
import (
"net/http"
"strings"
"mtusi2026-messenger/internal/dto"
)
const (
BasicChallenge = `Basic realm="messenger", charset="UTF-8"`
BearerChallenge = `Bearer realm="messenger"`
)
func BearerToken(r *http.Request) (string, bool) {
const prefix = "Bearer "
header := r.Header.Get("Authorization")
if len(header) <= len(prefix) || !strings.EqualFold(header[:len(prefix)], prefix) {
return "", false
}
token := strings.TrimSpace(header[len(prefix):])
return token, token != ""
}
func WriteUnauthorized(w http.ResponseWriter, challenge, requestID string) {
w.Header().Set("WWW-Authenticate", challenge)
WriteError(
w,
http.StatusUnauthorized,
dto.ErrorCodeUnauthorized,
"unauthorized",
requestID,
)
}
+34
View File
@@ -0,0 +1,34 @@
package httpx
import (
"net/http"
"strconv"
"mtusi2026-messenger/internal/dto"
)
func ParsePagination(w http.ResponseWriter, r *http.Request, requestID string) (limit int, cursor *string, ok bool) {
q := r.URL.Query()
limit = 50
if raw := q.Get("limit"); raw != "" {
v, err := strconv.Atoi(raw)
if err != nil || v < 1 || v > 100 {
WriteError(
w,
http.StatusBadRequest,
dto.ErrorCodeInvalidRequest,
"limit must be an integer between 1 and 100",
requestID,
)
return 0, nil, false
}
limit = v
}
if raw := q.Get("cursor"); raw != "" {
cursor = &raw
}
return limit, cursor, true
}
+36
View File
@@ -0,0 +1,36 @@
package httpx
import (
"encoding/json"
"errors"
"io"
"mime"
"net/http"
"mtusi2026-messenger/internal/dto"
)
func DecodeJSONBody(w http.ResponseWriter, r *http.Request, requestID string, dst any) bool {
if ct := r.Header.Get("Content-Type"); ct != "" {
mt, _, err := mime.ParseMediaType(ct)
if err != nil || mt != "application/json" {
WriteError(w, http.StatusUnsupportedMediaType, dto.ErrorCodeUnsupportedMediaType, "expected application/json", requestID)
return false
}
}
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(dst); err != nil {
WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid request body", requestID)
return false
}
if err := decoder.Decode(&struct{}{}); !errors.Is(err, io.EOF) {
WriteError(w, http.StatusBadRequest, dto.ErrorCodeInvalidRequest, "invalid request body", requestID)
return false
}
return true
}
+67
View File
@@ -0,0 +1,67 @@
package httpx
import (
"context"
"encoding/json"
"errors"
"net"
"net/http"
"strings"
"github.com/jackc/pgx/v5/pgconn"
"mtusi2026-messenger/internal/dto"
)
func WriteJSON(w http.ResponseWriter, status int, body any) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(body)
}
func WriteError(w http.ResponseWriter, status int, code dto.ErrorCode, message, requestID string) {
WriteJSON(w, status, dto.ErrorResponse{
Error: dto.Error{
Code: code,
Message: message,
RequestID: requestID,
},
})
}
func WriteInternalError(w http.ResponseWriter, requestID string, err error) {
if isUnavailable(err) {
WriteError(
w,
http.StatusServiceUnavailable,
dto.ErrorCodeUnavailable,
"dependency unavailable",
requestID,
)
return
}
WriteError(
w,
http.StatusInternalServerError,
dto.ErrorCodeInternalError,
"internal server error",
requestID,
)
}
func isUnavailable(err error) bool {
if errors.Is(err, context.DeadlineExceeded) {
return true
}
if _, ok := errors.AsType[net.Error](err); ok {
return true
}
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok {
return strings.HasPrefix(pgErr.Code, "08") || pgErr.Code == "57P01"
}
return false
}
+14
View File
@@ -0,0 +1,14 @@
package logger
import (
"log/slog"
"os"
)
func New(level slog.Level) *slog.Logger {
return slog.New(
slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
Level: level,
}),
)
}
+50
View File
@@ -0,0 +1,50 @@
package middleware
import (
"context"
"errors"
"net/http"
"github.com/google/uuid"
"mtusi2026-messenger/internal/httpx"
"mtusi2026-messenger/internal/service"
)
type userIDContextKey struct{}
type authenticator interface {
Authenticate(ctx context.Context, token string) (uuid.UUID, error)
}
func Auth(auth authenticator) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestID := GetRequestID(r.Context())
token, ok := httpx.BearerToken(r)
if !ok {
httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID)
return
}
userID, err := auth.Authenticate(r.Context(), token)
if errors.Is(err, service.ErrUnauthorized) {
httpx.WriteUnauthorized(w, httpx.BearerChallenge, requestID)
return
}
if err != nil {
httpx.WriteInternalError(w, requestID, err)
return
}
ctx := context.WithValue(r.Context(), userIDContextKey{}, userID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
func GetUserID(ctx context.Context) uuid.UUID {
id, _ := ctx.Value(userIDContextKey{}).(uuid.UUID)
return id
}
+41
View File
@@ -0,0 +1,41 @@
package middleware
import (
"net/http"
"mtusi2026-messenger/internal/dto"
"mtusi2026-messenger/internal/httpx"
)
func ConcurrencyLimit(max int) func(http.Handler) http.Handler {
if max <= 0 {
return func(next http.Handler) http.Handler {
return next
}
}
slots := make(chan struct{}, max)
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
select {
case slots <- struct{}{}:
defer func() {
<-slots
}()
next.ServeHTTP(w, r)
default:
w.Header().Set("Retry-After", "1")
httpx.WriteError(
w,
http.StatusTooManyRequests,
dto.ErrorCodeRateLimited,
"too many requests",
GetRequestID(r.Context()),
)
}
})
}
}
+49
View File
@@ -0,0 +1,49 @@
package middleware
import (
"log/slog"
"net/http"
"time"
)
type responseWriter struct {
http.ResponseWriter
status int
}
func (w *responseWriter) WriteHeader(status int) {
w.status = status
w.ResponseWriter.WriteHeader(status)
}
func Logging(log *slog.Logger) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
writer := &responseWriter{
ResponseWriter: w,
status: http.StatusOK,
}
next.ServeHTTP(writer, r)
level := slog.LevelInfo
switch {
case writer.status >= 500:
level = slog.LevelError
case writer.status >= 400:
level = slog.LevelWarn
}
log.Log(r.Context(), level, "http request",
"request_id", GetRequestID(r.Context()),
"method", r.Method,
"path", r.URL.Path,
"status", writer.status,
"duration_ms", time.Since(start).Milliseconds(),
)
})
}
}
+30
View File
@@ -0,0 +1,30 @@
package middleware
import (
"context"
"net/http"
"github.com/google/uuid"
)
type requestIDContextKey struct{}
func RequestID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestID := r.Header.Get("X-Request-Id")
if requestID == "" {
requestID = uuid.NewString()
}
w.Header().Set("X-Request-Id", requestID)
ctx := context.WithValue(r.Context(), requestIDContextKey{}, requestID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
func GetRequestID(ctx context.Context) string {
id, _ := ctx.Value(requestIDContextKey{}).(string)
return id
}
+17
View File
@@ -0,0 +1,17 @@
package middleware
import (
"context"
"net/http"
"time"
)
func RequestTimeout(d time.Duration) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), d)
defer cancel()
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
+14
View File
@@ -0,0 +1,14 @@
package model
import (
"time"
"github.com/google/uuid"
)
type Chat struct {
ID uuid.UUID
Title string
MemberIDs []uuid.UUID
CreatedAt time.Time
}
+15
View File
@@ -0,0 +1,15 @@
package model
import (
"time"
"github.com/google/uuid"
)
type Message struct {
ID uuid.UUID
ChatID uuid.UUID
SenderID uuid.UUID
Text string
CreatedAt time.Time
}
+9
View File
@@ -0,0 +1,9 @@
package model
import "time"
type Session struct {
Token string
ExpiresAt time.Time
User User
}
+14
View File
@@ -0,0 +1,14 @@
package model
import (
"time"
"github.com/google/uuid"
)
type User struct {
ID uuid.UUID
Username string
DisplayName string
CreatedAt time.Time
}
+25
View File
@@ -0,0 +1,25 @@
package postgres
import (
"errors"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
)
const (
CodeUniqueViolation = "23505"
CodeForeignKeyViolation = "23503"
CodeCheckViolation = "23514"
)
func ErrCode(err error) string {
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok {
return pgErr.Code
}
return ""
}
func IsNotFound(err error) bool {
return errors.Is(err, pgx.ErrNoRows)
}
+34
View File
@@ -0,0 +1,34 @@
package postgres
import (
"context"
"fmt"
"time"
"github.com/jackc/pgx/v5/pgxpool"
)
func New(ctx context.Context, url string) (*pgxpool.Pool, error) {
cfg, err := pgxpool.ParseConfig(url)
if err != nil {
return nil, fmt.Errorf("parse database url: %w", err)
}
cfg.MaxConns = 10
cfg.ConnConfig.ConnectTimeout = 5 * time.Second
cfg.ConnConfig.RuntimeParams["statement_timeout"] = "5000"
pool, err := pgxpool.NewWithConfig(ctx, cfg)
if err != nil {
return nil, fmt.Errorf("create pool: %w", err)
}
pingCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, fmt.Errorf("ping database: %w", err)
}
return pool, nil
}
+32
View File
@@ -0,0 +1,32 @@
package redis
import (
"context"
"fmt"
"log/slog"
"time"
goredis "github.com/redis/go-redis/v9"
)
func New(ctx context.Context, log *slog.Logger, url string) (*goredis.Client, error) {
opts, err := goredis.ParseURL(url)
if err != nil {
return nil, fmt.Errorf("parse redis url: %w", err)
}
opts.DialTimeout = 1 * time.Second
opts.ReadTimeout = 200 * time.Millisecond
opts.WriteTimeout = 200 * time.Millisecond
opts.MaxRetries = -1
client := goredis.NewClient(opts)
pingCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
if err := client.Ping(pingCtx).Err(); err != nil {
log.Warn("redis unavailable, running without cache", "error", err)
}
return client, nil
}
+152
View File
@@ -0,0 +1,152 @@
package service
import (
"context"
"errors"
"log/slog"
"time"
"mtusi2026-messenger/internal/credentials"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/model"
"mtusi2026-messenger/internal/postgres"
"github.com/google/uuid"
goredis "github.com/redis/go-redis/v9"
)
const sessionCacheTTL = 60 * time.Second
const cacheOpTimeout = 300 * time.Millisecond
var (
ErrInvalidCredentials = errors.New("invalid credentials")
ErrUnauthorized = errors.New("unauthorized")
)
type authQueries interface {
CreateSession(ctx context.Context, arg db.CreateSessionParams) error
DeleteSession(ctx context.Context, tokenHash string) (int64, error)
GetActiveSession(ctx context.Context, tokenHash string) (db.GetActiveSessionRow, error)
GetUserByUsername(ctx context.Context, username string) (db.User, error)
}
type AuthService struct {
q authQueries
cache *goredis.Client
sessionTTL time.Duration
log *slog.Logger
}
func NewAuthService(q authQueries, cache *goredis.Client, sessionTTL time.Duration, log *slog.Logger) *AuthService {
return &AuthService{
q: q,
cache: cache,
sessionTTL: sessionTTL,
log: log,
}
}
var dummyHash, _ = credentials.HashPassword("dummy-password-for-timing")
func (s *AuthService) Login(ctx context.Context, username, plain string) (model.Session, error) {
user, err := s.q.GetUserByUsername(ctx, username)
if postgres.IsNotFound(err) {
_ = credentials.VerifyPassword(dummyHash, plain)
return model.Session{}, ErrInvalidCredentials
}
if err != nil {
return model.Session{}, err
}
if err := credentials.VerifyPassword(user.PasswordHash, plain); err != nil {
if errors.Is(err, credentials.ErrPasswordMismatch) {
return model.Session{}, ErrInvalidCredentials
}
return model.Session{}, err
}
token := credentials.NewToken()
expiresAt := time.Now().UTC().Add(s.sessionTTL)
err = s.q.CreateSession(ctx, db.CreateSessionParams{
TokenHash: credentials.HashToken(token),
UserID: user.ID,
ExpiresAt: expiresAt,
})
if err != nil {
return model.Session{}, err
}
return model.Session{
Token: token,
ExpiresAt: expiresAt,
User: model.User{
ID: user.ID,
Username: user.Username,
DisplayName: user.DisplayName,
CreatedAt: user.CreatedAt.UTC(),
},
}, nil
}
func (s *AuthService) Authenticate(ctx context.Context, token string) (uuid.UUID, error) {
tokenHash := credentials.HashToken(token)
key := cacheKey(tokenHash)
cctx, cancel := context.WithTimeout(ctx, cacheOpTimeout)
val, err := s.cache.Get(cctx, key).Result()
cancel()
if err == nil {
id, perr := uuid.Parse(val)
if perr == nil {
return id, nil
}
s.log.Warn("session cache value is not a uuid", "error", perr)
} else if !errors.Is(err, goredis.Nil) {
s.log.Warn("session cache get failed, falling back to database", "error", err)
}
row, err := s.q.GetActiveSession(ctx, tokenHash)
if postgres.IsNotFound(err) {
return uuid.Nil, ErrUnauthorized
}
if err != nil {
return uuid.Nil, err
}
ttl := min(time.Until(row.ExpiresAt), sessionCacheTTL)
if ttl > 0 {
cctx, cancel = context.WithTimeout(ctx, cacheOpTimeout)
if err := s.cache.Set(cctx, key, row.UserID.String(), ttl).Err(); err != nil {
s.log.Warn("session cache set failed", "error", err)
}
cancel()
}
return row.UserID, nil
}
func (s *AuthService) Logout(ctx context.Context, token string) error {
tokenHash := credentials.HashToken(token)
n, err := s.q.DeleteSession(ctx, tokenHash)
if err != nil {
return err
}
cctx, cancel := context.WithTimeout(ctx, cacheOpTimeout)
defer cancel()
if err := s.cache.Del(cctx, cacheKey(tokenHash)).Err(); err != nil {
s.log.Warn("session cache delete failed", "error", err)
}
if n == 0 {
return ErrUnauthorized
}
return nil
}
func cacheKey(tokenHash string) string {
return "session:" + tokenHash
}
+208
View File
@@ -0,0 +1,208 @@
package service
import (
"bytes"
"context"
"errors"
"slices"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/model"
"mtusi2026-messenger/internal/postgres"
)
var (
ErrChatNotFound = errors.New("chat not found")
ErrNotChatMember = errors.New("caller must be a member of member_ids")
ErrDuplicateMember = errors.New("member_ids contains duplicates")
ErrUnknownMember = errors.New("member_ids contains unknown user")
)
type chatQueries interface {
AddChatMembers(ctx context.Context, arg db.AddChatMembersParams) error
CreateChat(ctx context.Context, arg db.CreateChatParams) (db.Chat, error)
GetChat(ctx context.Context, arg db.GetChatParams) (db.GetChatRow, error)
ListChatsAfter(ctx context.Context, arg db.ListChatsAfterParams) ([]db.ListChatsAfterRow, error)
ListChatsFirstPage(ctx context.Context, arg db.ListChatsFirstPageParams) ([]db.ListChatsFirstPageRow, error)
}
type txBeginner interface {
Begin(ctx context.Context) (pgx.Tx, error)
}
type ChatService struct {
pool txBeginner
q chatQueries
withTx func(pgx.Tx) chatQueries
}
func NewChatService(pool *pgxpool.Pool, q *db.Queries) *ChatService {
return &ChatService{
pool: pool,
q: q,
withTx: func(tx pgx.Tx) chatQueries {
return q.WithTx(tx)
},
}
}
func (s *ChatService) Create(
ctx context.Context,
userID uuid.UUID,
title string,
memberIDs []uuid.UUID,
) (model.Chat, error) {
if !slices.Contains(memberIDs, userID) {
return model.Chat{}, ErrNotChatMember
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return model.Chat{}, err
}
defer tx.Rollback(ctx)
q := s.withTx(tx)
id, err := uuid.NewV7()
if err != nil {
return model.Chat{}, err
}
row, err := q.CreateChat(ctx, db.CreateChatParams{
ID: id,
Title: title,
})
if err != nil {
return model.Chat{}, err
}
err = q.AddChatMembers(ctx, db.AddChatMembersParams{
ChatID: row.ID,
UserIds: memberIDs,
})
switch postgres.ErrCode(err) {
case postgres.CodeUniqueViolation:
return model.Chat{}, ErrDuplicateMember
case postgres.CodeForeignKeyViolation:
return model.Chat{}, ErrUnknownMember
}
if err != nil {
return model.Chat{}, err
}
if err := tx.Commit(ctx); err != nil {
return model.Chat{}, err
}
ids := slices.Clone(memberIDs)
slices.SortFunc(ids, func(a, b uuid.UUID) int {
return bytes.Compare(a[:], b[:])
})
return model.Chat{
ID: row.ID,
Title: row.Title,
CreatedAt: row.CreatedAt,
MemberIDs: ids,
}, nil
}
func (s *ChatService) Get(
ctx context.Context,
userID uuid.UUID,
chatID uuid.UUID,
) (model.Chat, error) {
row, err := s.q.GetChat(ctx, db.GetChatParams{
ID: chatID,
UserID: userID,
})
if postgres.IsNotFound(err) {
return model.Chat{}, ErrChatNotFound
}
if err != nil {
return model.Chat{}, err
}
return model.Chat{
ID: row.ID,
Title: row.Title,
CreatedAt: row.CreatedAt,
MemberIDs: row.MemberIds,
}, nil
}
func (s *ChatService) List(
ctx context.Context,
userID uuid.UUID,
limit int,
cursor *string,
) ([]model.Chat, *string, error) {
var chats []model.Chat
if cursor == nil {
rows, err := s.q.ListChatsFirstPage(ctx, db.ListChatsFirstPageParams{
UserID: userID,
Lim: int32(limit + 1),
})
if err != nil {
return nil, nil, err
}
chats = make([]model.Chat, 0, len(rows))
for _, r := range rows {
chats = append(chats, model.Chat{
ID: r.ID,
Title: r.Title,
CreatedAt: r.CreatedAt,
MemberIDs: r.MemberIds,
})
}
} else {
decoded, derr := decodeCursor(*cursor, uuid.Nil)
if derr != nil {
return nil, nil, ErrInvalidCursor
}
rows, err := s.q.ListChatsAfter(ctx, db.ListChatsAfterParams{
UserID: userID,
AfterCreatedAt: decoded.CreatedAt,
AfterID: decoded.ID,
Lim: int32(limit + 1),
})
if err != nil {
return nil, nil, err
}
chats = make([]model.Chat, 0, len(rows))
for _, r := range rows {
chats = append(chats, model.Chat{
ID: r.ID,
Title: r.Title,
CreatedAt: r.CreatedAt,
MemberIDs: r.MemberIds,
})
}
}
hasMore := len(chats) > limit
if hasMore {
chats = chats[:limit]
}
var next *string
if hasMore {
last := chats[len(chats)-1]
c := encodeCursor(Cursor{
CreatedAt: last.CreatedAt,
ID: last.ID,
})
next = &c
}
return chats, next, nil
}
+41
View File
@@ -0,0 +1,41 @@
package service
import (
"encoding/base64"
"encoding/json"
"errors"
"time"
"github.com/google/uuid"
)
var ErrInvalidCursor = errors.New("invalid cursor")
type Cursor struct {
ChatID uuid.UUID `json:"chat_id"`
CreatedAt time.Time `json:"created_at"`
ID uuid.UUID `json:"id"`
}
func encodeCursor(cursor Cursor) string {
data, _ := json.Marshal(cursor)
return base64.RawURLEncoding.EncodeToString(data)
}
func decodeCursor(raw string, chatID uuid.UUID) (Cursor, error) {
data, err := base64.RawURLEncoding.DecodeString(raw)
if err != nil {
return Cursor{}, ErrInvalidCursor
}
var cursor Cursor
if err := json.Unmarshal(data, &cursor); err != nil {
return Cursor{}, ErrInvalidCursor
}
if cursor.ID == uuid.Nil || cursor.CreatedAt.IsZero() || cursor.ChatID != chatID {
return Cursor{}, ErrInvalidCursor
}
return cursor, nil
}
+134
View File
@@ -0,0 +1,134 @@
package service
import (
"context"
"errors"
"github.com/google/uuid"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/model"
"mtusi2026-messenger/internal/postgres"
)
var ErrMessageChatNotFound = errors.New("chat not found")
type messageQueries interface {
CreateMessage(ctx context.Context, arg db.CreateMessageParams) (db.Message, error)
IsChatMember(ctx context.Context, arg db.IsChatMemberParams) (bool, error)
ListMessagesAfter(ctx context.Context, arg db.ListMessagesAfterParams) ([]db.Message, error)
ListMessagesFirstPage(ctx context.Context, arg db.ListMessagesFirstPageParams) ([]db.Message, error)
}
type MessageService struct {
q messageQueries
}
func NewMessageService(q *db.Queries) *MessageService {
return &MessageService{q: q}
}
func (s *MessageService) Create(
ctx context.Context,
userID uuid.UUID,
chatID uuid.UUID,
text string,
) (model.Message, error) {
id, err := uuid.NewV7()
if err != nil {
return model.Message{}, err
}
row, err := s.q.CreateMessage(ctx, db.CreateMessageParams{
ID: id,
ChatID: chatID,
SenderID: userID,
Text: text,
})
if postgres.IsNotFound(err) {
return model.Message{}, ErrMessageChatNotFound
}
if err != nil {
return model.Message{}, err
}
return model.Message{
ID: row.ID,
ChatID: row.ChatID,
SenderID: row.SenderID,
Text: row.Text,
CreatedAt: row.CreatedAt,
}, nil
}
func (s *MessageService) List(
ctx context.Context,
userID uuid.UUID,
chatID uuid.UUID,
limit int,
cursor *string,
) ([]model.Message, *string, error) {
isMember, err := s.q.IsChatMember(ctx, db.IsChatMemberParams{
ChatID: chatID,
UserID: userID,
})
if err != nil {
return nil, nil, err
}
if !isMember {
return nil, nil, ErrMessageChatNotFound
}
var rows []db.Message
if cursor == nil {
rows, err = s.q.ListMessagesFirstPage(ctx, db.ListMessagesFirstPageParams{
ChatID: chatID,
Lim: int32(limit + 1),
})
} else {
decoded, derr := decodeCursor(*cursor, chatID)
if derr != nil {
return nil, nil, ErrInvalidCursor
}
rows, err = s.q.ListMessagesAfter(ctx, db.ListMessagesAfterParams{
ChatID: chatID,
AfterCreatedAt: decoded.CreatedAt,
AfterID: decoded.ID,
Lim: int32(limit + 1),
})
}
if err != nil {
return nil, nil, err
}
hasMore := len(rows) > limit
if hasMore {
rows = rows[:limit]
}
messages := make([]model.Message, 0, len(rows))
for _, r := range rows {
messages = append(messages, model.Message{
ID: r.ID,
ChatID: r.ChatID,
SenderID: r.SenderID,
Text: r.Text,
CreatedAt: r.CreatedAt,
})
}
var next *string
if hasMore {
last := messages[len(messages)-1]
c := encodeCursor(Cursor{
ChatID: chatID,
CreatedAt: last.CreatedAt,
ID: last.ID,
})
next = &c
}
return messages, next, nil
}
+83
View File
@@ -0,0 +1,83 @@
package service
import (
"context"
"errors"
"github.com/google/uuid"
"mtusi2026-messenger/internal/credentials"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/model"
"mtusi2026-messenger/internal/postgres"
)
var (
ErrUsernameTaken = errors.New("username already taken")
ErrUserNotFound = errors.New("user not found")
)
type userQueries interface {
CreateUser(ctx context.Context, arg db.CreateUserParams) (db.CreateUserRow, error)
GetUser(ctx context.Context, id uuid.UUID) (db.GetUserRow, error)
}
type UserService struct {
q userQueries
}
func NewUserService(q userQueries) *UserService {
return &UserService{q: q}
}
func (s *UserService) Create(
ctx context.Context,
username, displayName, plain string,
) (model.User, error) {
hash, err := credentials.HashPassword(plain)
if err != nil {
return model.User{}, err
}
id, err := uuid.NewV7()
if err != nil {
return model.User{}, err
}
row, err := s.q.CreateUser(ctx, db.CreateUserParams{
ID: id,
Username: username,
DisplayName: displayName,
PasswordHash: hash,
})
if err != nil {
if postgres.ErrCode(err) == postgres.CodeUniqueViolation {
return model.User{}, ErrUsernameTaken
}
return model.User{}, err
}
return model.User{
ID: row.ID,
Username: row.Username,
DisplayName: row.DisplayName,
CreatedAt: row.CreatedAt.UTC(),
}, nil
}
func (s *UserService) GetByID(ctx context.Context, id uuid.UUID) (model.User, error) {
row, err := s.q.GetUser(ctx, id)
if postgres.IsNotFound(err) {
return model.User{}, ErrUserNotFound
}
if err != nil {
return model.User{}, err
}
return model.User{
ID: row.ID,
Username: row.Username,
DisplayName: row.DisplayName,
CreatedAt: row.CreatedAt.UTC(),
}, nil
}
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
docker compose restart postgres redis api
+30
View File
@@ -0,0 +1,30 @@
version: "2"
sql:
- engine: "postgresql"
queries: "db/queries"
schema: "db/migrations"
gen:
go:
package: "db"
out: "internal/db"
sql_package: "pgx/v5"
emit_empty_slices: true
emit_pointers_for_null_types: true
overrides:
- db_type: "uuid"
go_type: "github.com/google/uuid.UUID"
- db_type: "uuid"
nullable: true
go_type:
import: "github.com/google/uuid"
type: "UUID"
pointer: true
- db_type: "timestamptz"
go_type: "time.Time"
- db_type: "timestamptz"
nullable: true
go_type:
import: "time"
type: "Time"
pointer: true
+55
View File
@@ -0,0 +1,55 @@
//go:build contract
package studenttests_test
import (
"context"
"encoding/json"
"net/http"
"os"
"strings"
"testing"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
)
func TestCreateChatRollback(t *testing.T) {
data, err := os.ReadFile("../secrets/test_database_url.txt")
if err != nil {
t.Fatalf("read secrets/test_database_url: %v", err)
}
ctx := context.Background()
conn, err := pgx.Connect(ctx, strings.TrimSpace(string(data)))
if err != nil {
t.Fatalf("connect to database: %v", err)
}
defer conn.Close(ctx)
creator := createUser(t)
title := "rollback-" + uuid.NewString()
body, err := json.Marshal(map[string]any{
"title": title,
"member_ids": []uuid.UUID{creator.ID, uuid.New()},
})
if err != nil {
t.Fatalf("marshal body: %v", err)
}
resp := doRequest(t, http.MethodPost, "/api/v1/chats", creator.Token, body)
resp.Body.Close()
if resp.StatusCode < 400 || resp.StatusCode >= 500 {
t.Fatalf("expected 4xx, got %d", resp.StatusCode)
}
var n int
err = conn.QueryRow(ctx, "SELECT count(*) FROM chats WHERE title = $1", title).Scan(&n)
if err != nil {
t.Fatalf("count chats: %v", err)
}
if n != 0 {
t.Fatalf("expected no chat rows after failed creation, found %d", n)
}
}
+134
View File
@@ -0,0 +1,134 @@
//go:build contract
package studenttests_test
import (
"encoding/json"
"net/http"
"net/url"
"strconv"
"testing"
"mtusi2026-messenger/internal/dto"
)
func TestInvalidJSON(t *testing.T) {
resp := doRequest(t, http.MethodPost, "/api/v1/users", "", []byte(`{"username": "broken",`))
requireStatus(t, resp, http.StatusBadRequest)
var apiErr dto.ErrorResponse
mustDecode(t, resp, &apiErr)
if apiErr.Error.Code != dto.ErrorCodeInvalidRequest {
t.Errorf("expected code %q, got %q", dto.ErrorCodeInvalidRequest, apiErr.Error.Code)
}
}
func TestForeignChat(t *testing.T) {
user1 := createUser(t)
user2 := createUser(t)
user3 := createUser(t)
chat := createChat(t, user1, user1.ID, user2.ID)
resp := doRequest(t, http.MethodGet, "/api/v1/chats/"+chat.ID.String(), user3.Token, nil)
requireStatus(t, resp, http.StatusNotFound)
resp = sendMessage(t, user3, chat.ID, "should not land")
requireStatus(t, resp, http.StatusNotFound)
}
func TestEmptyMessage(t *testing.T) {
user := createUser(t)
chat := createChat(t, user, user.ID)
for _, text := range []string{"", " ", "\t\n"} {
resp := sendMessage(t, user, chat.ID, text)
requireStatus(t, resp, http.StatusBadRequest)
}
}
func TestDuplicateUsername(t *testing.T) {
user := createUser(t)
body, err := json.Marshal(map[string]string{
"username": user.Username,
"display_name": "Someone else",
"password": testPassword,
})
if err != nil {
t.Fatalf("marshal body: %v", err)
}
resp := doRequest(t, http.MethodPost, "/api/v1/users", "", body)
requireStatus(t, resp, http.StatusConflict)
var apiErr dto.ErrorResponse
mustDecode(t, resp, &apiErr)
if apiErr.Error.Code != dto.ErrorCodeConflict {
t.Errorf("expected code %q, got %q", dto.ErrorCodeConflict, apiErr.Error.Code)
}
}
func TestPagination(t *testing.T) {
user := createUser(t)
chat := createChat(t, user, user.ID)
const total = 25
const pageSize = 4
sent := make(map[string]bool, total)
for i := 0; i < total; i++ {
resp := sendMessage(t, user, chat.ID, "msg")
requireStatus(t, resp, http.StatusCreated)
var msg dto.MessageResponse
mustDecode(t, resp, &msg)
sent[msg.ID.String()] = true
}
seen := make(map[string]bool, total)
cursor := ""
pages := 0
for {
path := "/api/v1/chats/" + chat.ID.String() + "/messages?limit=" + strconv.Itoa(pageSize)
if cursor != "" {
path += "&cursor=" + url.QueryEscape(cursor)
}
resp := doRequest(t, http.MethodGet, path, user.Token, nil)
requireStatus(t, resp, http.StatusOK)
var page dto.MessagePageResponse
mustDecode(t, resp, &page)
pages++
for _, msg := range page.Items {
id := msg.ID.String()
if seen[id] {
t.Fatalf("duplicate message id across pages: %s", id)
}
seen[id] = true
}
if page.NextCursor == nil {
break
}
cursor = *page.NextCursor
if pages > total {
t.Fatalf("too many pages: got %d, expected at most %d", pages, total)
}
}
if len(seen) != total {
t.Fatalf("expected %d unique messages across all pages, got %d", total, len(seen))
}
for id := range sent {
if !seen[id] {
t.Fatalf("message %s sent but never seen while paginating", id)
}
}
}
+89
View File
@@ -0,0 +1,89 @@
//go:build failure
package studenttests_test
import (
"net/http"
"os/exec"
"testing"
"time"
)
func compose(t *testing.T, args ...string) {
t.Helper()
cmd := exec.Command("docker", append([]string{"compose"}, args...)...)
cmd.Dir = ".."
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("docker compose %v: %v\n%s", args, err, out)
}
}
func stopService(t *testing.T, name string) {
t.Helper()
compose(t, "stop", name)
t.Cleanup(func() {
compose(t, "start", name)
waitReady(t)
})
}
func waitReady(t *testing.T) {
t.Helper()
deadline := time.Now().Add(60 * time.Second)
for time.Now().Before(deadline) {
resp, err := httpClient.Get(*baseURL + "/health/ready")
if err == nil {
resp.Body.Close()
if resp.StatusCode == http.StatusOK {
return
}
}
time.Sleep(500 * time.Millisecond)
}
t.Fatal("service did not become ready in 60s")
}
func TestRedisDown(t *testing.T) {
user := createUser(t)
stopService(t, "redis")
// настоящий токен
resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
requireStatus(t, resp, http.StatusOK)
resp.Body.Close()
// выдуманный токен
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "forged-"+user.Token, nil)
requireStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
// без токена
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "", nil)
requireStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
}
func TestDatabaseDown(t *testing.T) {
user := createUser(t) // токен ещё не использован, ключа в Redis нет
stopService(t, "postgres")
// ключа в кэше нет, проверить сессию негде
resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
requireStatus(t, resp, http.StatusServiceUnavailable)
resp.Body.Close()
// выдуманный токен
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "forged-"+user.Token, nil)
requireStatus(t, resp, http.StatusServiceUnavailable)
resp.Body.Close()
// без токена
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", "", nil)
requireStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
}
+218
View File
@@ -0,0 +1,218 @@
package studenttests_test
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"io"
"net/http"
"strings"
"testing"
"time"
"github.com/google/uuid"
"mtusi2026-messenger/internal/dto"
)
var baseURL = flag.String("base-url", "http://127.0.0.1:8080", "base URL of the running server")
var httpClient = &http.Client{
Timeout: 10 * time.Second,
Transport: &http.Transport{
MaxIdleConns: 200,
IdleConnTimeout: 30 * time.Second,
MaxIdleConnsPerHost: 200,
MaxConnsPerHost: 200,
},
}
type testUser struct {
dto.UserResponse
Token string
}
const testPassword = "correct-horse-battery"
func doRequest(t *testing.T, method, path, token string, body []byte) *http.Response {
t.Helper()
req, err := http.NewRequest(method, *baseURL+path, bytes.NewReader(body))
if err != nil {
t.Fatalf("build request: %v", err)
}
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
if token != "" {
req.Header.Set("Authorization", "Bearer "+token)
}
resp, err := httpClient.Do(req)
if err != nil {
t.Fatalf("%s %s: request failed: %v", method, path, err)
}
return resp
}
func mustDecode(t *testing.T, resp *http.Response, dst any) {
t.Helper()
defer resp.Body.Close()
data, err := io.ReadAll(resp.Body)
if err != nil {
t.Fatalf("read body: %v", err)
}
if err := json.Unmarshal(data, dst); err != nil {
t.Fatalf("decode body %q: %v", data, err)
}
}
func requireStatus(t *testing.T, resp *http.Response, expected int) {
t.Helper()
if resp.StatusCode != expected {
data, _ := io.ReadAll(resp.Body)
resp.Body.Close()
t.Fatalf(
"expected status %d, got %d, body: %s",
expected,
resp.StatusCode,
data,
)
}
if resp.Header.Get("X-Request-Id") == "" {
t.Errorf("missing X-Request-Id header")
}
}
func createUser(t *testing.T) testUser {
t.Helper()
username := "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:12]
body, err := json.Marshal(map[string]string{
"username": username,
"display_name": "Test " + username,
"password": testPassword,
})
if err != nil {
t.Fatalf("marshal user: %v", err)
}
resp := doRequest(t, http.MethodPost, "/api/v1/users", "", body)
requireStatus(t, resp, http.StatusCreated)
var u dto.UserResponse
mustDecode(t, resp, &u)
req, err := http.NewRequest(
http.MethodPost,
*baseURL+"/api/v1/auth/sessions",
nil,
)
if err != nil {
t.Fatalf("build login request: %v", err)
}
req.SetBasicAuth(username, testPassword)
resp, err = httpClient.Do(req)
if err != nil {
t.Fatalf("login request failed: %v", err)
}
requireStatus(t, resp, http.StatusCreated)
var session dto.SessionResponse
mustDecode(t, resp, &session)
return testUser{UserResponse: u, Token: session.Token}
}
func createChat(
t *testing.T,
creator testUser,
memberIDs ...uuid.UUID,
) dto.ChatResponse {
t.Helper()
body, err := json.Marshal(map[string]any{
"title": "Test chat " + uuid.NewString()[:8],
"member_ids": memberIDs,
})
if err != nil {
t.Fatalf("marshal chat: %v", err)
}
resp := doRequest(
t,
http.MethodPost,
"/api/v1/chats",
creator.Token,
body,
)
requireStatus(t, resp, http.StatusCreated)
var c dto.ChatResponse
mustDecode(t, resp, &c)
return c
}
func sendMessage(
t *testing.T,
actor testUser,
chatID uuid.UUID,
text string,
) *http.Response {
t.Helper()
body, err := json.Marshal(map[string]string{
"text": text,
})
if err != nil {
t.Fatalf("marshal message: %v", err)
}
return doRequest(
t,
http.MethodPost,
fmt.Sprintf("/api/v1/chats/%v/messages", chatID.String()),
actor.Token,
body,
)
}
func sendLoadMessage(
actor testUser,
chatID uuid.UUID,
text string,
) (*http.Response, error) {
body, err := json.Marshal(map[string]string{
"text": text,
})
if err != nil {
return nil, err
}
req, err := http.NewRequest(
http.MethodPost,
*baseURL+"/api/v1/chats/"+chatID.String()+"/messages",
bytes.NewReader(body),
)
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+actor.Token)
return httpClient.Do(req)
}
+138
View File
@@ -0,0 +1,138 @@
//go:build load
package studenttests_test
import (
"flag"
"io"
"net/http"
"sort"
"sync"
"sync/atomic"
"testing"
"time"
)
var (
workers = flag.Int("workers", 20, "number of concurrent workers")
duration = flag.Duration("duration", 5*time.Second, "test duration")
rate = flag.Int("rate", 20, "maximum requests per second per worker")
)
func TestLoad(t *testing.T) {
var (
statuses = make(map[int]int64)
requestErrors int64
latencies []time.Duration
statusMu sync.Mutex
latencyMu sync.Mutex
wg sync.WaitGroup
)
user1 := createUser(t)
user2 := createUser(t)
chat := createChat(t, user1, user1.ID, user2.ID)
start := time.Now()
deadline := start.Add(*duration)
interval := time.Second / time.Duration(*rate)
for worker := 0; worker < *workers; worker++ {
wg.Add(1)
go func(workerID int) {
defer wg.Done()
actor := user1
if workerID%2 == 1 {
actor = user2
}
ticker := time.NewTicker(interval)
defer ticker.Stop()
for time.Now().Before(deadline) {
<-ticker.C
if time.Now().After(deadline) {
return
}
requestStart := time.Now()
resp, err := sendLoadMessage(
actor,
chat.ID,
"load-msg",
)
latency := time.Since(requestStart)
if err != nil {
if atomic.CompareAndSwapInt64(&requestErrors, 0, 1) {
t.Logf("first transport error: %v", err)
}
atomic.AddInt64(&requestErrors, 1)
continue
}
statusMu.Lock()
statuses[resp.StatusCode]++
statusMu.Unlock()
if resp.StatusCode == http.StatusCreated {
latencyMu.Lock()
latencies = append(latencies, latency)
latencyMu.Unlock()
}
io.Copy(io.Discard, resp.Body)
resp.Body.Close()
}
}(worker)
}
wg.Wait()
elapsed := time.Since(start)
var total int64
for _, count := range statuses {
total += count
}
total += requestErrors
t.Logf("duration: %.3fs", elapsed.Seconds())
t.Logf("workers: %d", *workers)
t.Logf("rate per worker: %d req/s", *rate)
t.Logf("target rate: %d req/s", *workers**rate)
t.Logf("total requests: %d", total)
for status, count := range statuses {
t.Logf("HTTP %d: %d", status, count)
}
t.Logf("request errors: %d", requestErrors)
successful := statuses[http.StatusCreated]
t.Logf("successful RPS: %.2f",
float64(successful)/elapsed.Seconds(),
)
if len(latencies) > 0 {
sort.Slice(latencies, func(i, j int) bool {
return latencies[i] < latencies[j]
})
t.Logf("successful latency p50: %s", percentile(latencies, 0.50))
t.Logf("successful latency p95: %s", percentile(latencies, 0.95))
t.Logf("successful latency p99: %s", percentile(latencies, 0.99))
}
}
func percentile(values []time.Duration, p float64) time.Duration {
index := int(float64(len(values)-1) * p)
return values[index]
}
+100
View File
@@ -0,0 +1,100 @@
//go:build race
package studenttests_test
import (
"net/http"
"sync"
"testing"
"mtusi2026-messenger/internal/dto"
)
func TestConcurrentMessages(t *testing.T) {
const clients = 10
const messagesPerClient = 10
const total = clients * messagesPerClient
user1 := createUser(t)
user2 := createUser(t)
chat := createChat(t, user1, user1.ID, user2.ID)
var wg sync.WaitGroup
var mu sync.Mutex
sentIDs := make(map[string]bool, total)
start := make(chan struct{})
for worker := 0; worker < clients; worker++ {
wg.Add(1)
go func(workerID int) {
defer wg.Done()
actor := user1
if workerID%2 == 1 {
actor = user2
}
<-start
for i := 0; i < messagesPerClient; i++ {
resp := sendMessage(t, actor, chat.ID, "race-msg")
if resp.StatusCode != http.StatusCreated {
t.Errorf("worker %d msg %d: expected 201, got %d", workerID, i, resp.StatusCode)
resp.Body.Close()
continue
}
var m dto.MessageResponse
mustDecode(t, resp, &m)
mu.Lock()
sentIDs[m.ID.String()] = true
mu.Unlock()
}
}(worker)
}
close(start)
wg.Wait()
if t.Failed() {
t.Fatal("one or more send requests failed, see errors above")
}
if len(sentIDs) != total {
t.Fatalf("expected %d successful sends, got %d unique ids", total, len(sentIDs))
}
seen := make(map[string]bool, total)
path := "/api/v1/chats/" + chat.ID.String() + "/messages?limit=100"
resp := doRequest(t, http.MethodGet, path, user1.Token, nil)
requireStatus(t, resp, http.StatusOK)
var page dto.MessagePageResponse
mustDecode(t, resp, &page)
if page.NextCursor != nil {
t.Fatalf("expected next_cursor to be nil, history may contain more than %d messages", total)
}
for _, msg := range page.Items {
id := msg.ID.String()
if seen[id] {
t.Fatalf("duplicate message id in history: %s", id)
}
if !sentIDs[id] {
t.Fatalf("message %s in history was never sent by this test", id)
}
seen[id] = true
}
if len(seen) != total {
t.Fatalf("expected exactly %d unique messages in history, got %d", total, len(seen))
}
t.Logf("PASS: %d concurrent clients sent %d messages, exactly %d unique messages persisted",
clients, total, len(seen))
}
+77
View File
@@ -0,0 +1,77 @@
//go:build race
package studenttests_test
import (
"bytes"
"encoding/json"
"net/http"
"strings"
"sync"
"testing"
"github.com/google/uuid"
)
func TestConcurrentRegistration(t *testing.T) {
const workers = 20
username := "u_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:12]
body, err := json.Marshal(map[string]string{
"username": username,
"display_name": "Racer",
"password": testPassword,
})
if err != nil {
t.Fatalf("marshal body: %v", err)
}
start := make(chan struct{})
statuses := make(chan int, workers)
var wg sync.WaitGroup
for i := 0; i < workers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
<-start
req, err := http.NewRequest(http.MethodPost, *baseURL+"/api/v1/users", bytes.NewReader(body))
if err != nil {
t.Errorf("build request: %v", err)
return
}
req.Header.Set("Content-Type", "application/json")
resp, err := httpClient.Do(req)
if err != nil {
t.Errorf("request failed: %v", err)
return
}
defer resp.Body.Close()
statuses <- resp.StatusCode
}()
}
close(start)
wg.Wait()
close(statuses)
created, conflict := 0, 0
for s := range statuses {
switch s {
case http.StatusCreated:
created++
case http.StatusConflict:
conflict++
default:
t.Errorf("unexpected status %d", s)
}
}
if created != 1 || conflict != workers-1 {
t.Fatalf("expected 1 created and %d conflict, got %d created and %d conflict", workers-1, created, conflict)
}
}
+42
View File
@@ -0,0 +1,42 @@
//go:build failure
package studenttests_test
import (
"net/http"
"os/exec"
"testing"
"time"
)
const shortTTLContainer = "api-short-ttl"
const shortTTLURL = "http://localhost:8081"
func TestSessionExpiry(t *testing.T) {
_ = exec.Command("docker", "rm", "-f", shortTTLContainer).Run()
compose(t, "run", "-d", "--no-deps", "--name", shortTTLContainer,
"-e", "SESSION_TTL_SECONDS=3",
"-p", "127.0.0.1:8081:8080", "api")
t.Cleanup(func() {
_ = exec.Command("docker", "rm", "-f", shortTTLContainer).Run()
})
old := *baseURL
*baseURL = shortTTLURL
t.Cleanup(func() { *baseURL = old })
waitReady(t)
user := createUser(t)
resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
requireStatus(t, resp, http.StatusOK)
resp.Body.Close()
time.Sleep(4 * time.Second)
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
requireStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
}
+58
View File
@@ -0,0 +1,58 @@
//go:build contract
package studenttests_test
import (
"net/http"
"testing"
)
func basicLogin(t *testing.T, username, password string) *http.Response {
t.Helper()
req, err := http.NewRequest(http.MethodPost, *baseURL+"/api/v1/auth/sessions", nil)
if err != nil {
t.Fatalf("build login request: %v", err)
}
req.SetBasicAuth(username, password)
resp, err := httpClient.Do(req)
if err != nil {
t.Fatalf("login request failed: %v", err)
}
return resp
}
func TestLoginWrongPassword(t *testing.T) {
user := createUser(t)
resp := basicLogin(t, user.Username, "wrong-"+testPassword)
requireStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
resp = basicLogin(t, "no_such_user_"+user.Username, testPassword)
requireStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
}
func TestLogout(t *testing.T) {
user := createUser(t)
resp := doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
requireStatus(t, resp, http.StatusOK)
resp.Body.Close()
resp = doRequest(t, http.MethodDelete, "/api/v1/auth/sessions/current", user.Token, nil)
if resp.StatusCode >= 300 {
t.Fatalf("logout: unexpected status %d", resp.StatusCode)
}
resp.Body.Close()
resp = doRequest(t, http.MethodGet, "/api/v1/users/me", user.Token, nil)
requireStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
resp = doRequest(t, http.MethodDelete, "/api/v1/auth/sessions/current", user.Token, nil)
requireStatus(t, resp, http.StatusUnauthorized)
resp.Body.Close()
}
+23
View File
@@ -0,0 +1,23 @@
LOAD_ARGS = $(if $(LOAD_WORKERS),-workers=$(LOAD_WORKERS),) \
$(if $(LOAD_DURATION),-duration=$(LOAD_DURATION),) \
$(if $(LOAD_RATE),-rate=$(LOAD_RATE),)
.PHONY: help-go contract-go race-go load-go failure-go
help-go:
@echo "contract-go: contract tests"
@echo "race-go: concurrency tests (-race)"
@echo "load-go: load test"
@echo "failure-go: dependency failure tests (stops redis/postgres containers)"
contract-go:
go test -tags=contract ./student-tests/... -v -args -base-url=$(BASE_URL)
race-go:
go test -tags=race ./student-tests/... -race -v -args -base-url=$(BASE_URL)
load-go:
go test -tags=load ./student-tests/... -v -args -base-url=$(BASE_URL) $(LOAD_ARGS)
failure-go:
go test -tags=failure ./student-tests/... -v -args -base-url=$(BASE_URL)
+21
View File
@@ -0,0 +1,21 @@
<!DOCTYPE html>
<html lang="ru">
<head>
<meta charset="UTF-8">
<title>MTUSI Messenger API</title>
<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist/swagger-ui.css">
</head>
<body>
<div id="swagger-ui"></div>
<script src="https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js"></script>
<script>
window.onload = () => {
SwaggerUIBundle({
url: "/contracts/openapi.json",
dom_id: "#swagger-ui"
});
};
</script>
</body>
</html>