Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
a3acf1536e | ||
|
|
f3bb9dafea | ||
|
|
189847708f | ||
|
|
31bce63105 | ||
|
|
9872aa1cde |
+22
@@ -0,0 +1,22 @@
|
||||
# Первый этап: сборка приложения через Maven и JDK.
|
||||
FROM maven:3.9.9-eclipse-temurin-21 AS build
|
||||
# Рабочая папка внутри контейнера сборки.
|
||||
WORKDIR /build
|
||||
# Сначала копируем зависимости для ускорения повторной сборки.
|
||||
COPY pom.xml .
|
||||
RUN mvn -B -q dependency:go-offline
|
||||
# Копируем исходный код и собираем JAR-файл.
|
||||
COPY src src
|
||||
RUN mvn -B -q package -DskipTests
|
||||
# Второй этап: запускаем приложение в лёгком JRE-образе.
|
||||
FROM eclipse-temurin:21.0.4_7-jre-jammy
|
||||
WORKDIR /app
|
||||
# Переносим готовое приложение из этапа сборки.
|
||||
COPY --from=build /build/target/messenger-1.0.0.jar /app/messenger.jar
|
||||
# Запускаем контейнер не от root-пользователя.
|
||||
RUN useradd --system --uid 10001 app
|
||||
USER 10001
|
||||
# Приложение слушает порт 8080.
|
||||
EXPOSE 8080
|
||||
# Команда запуска Spring Boot-приложения.
|
||||
ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-jar","/app/messenger.jar"]
|
||||
@@ -1,37 +1,257 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Гавриков В.Д БПИ2303
|
||||
- Целевая оценка: 5
|
||||
- Трек уровня 5: план запросов и backup/восстановление PostgreSQL
|
||||
|
||||
## Запуск из чистого clone
|
||||
## Сценарий защиты
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Все команды выполняются в PowerShell из папки:
|
||||
|
||||
## Архитектура и решения
|
||||
```powershell
|
||||
cd C:\labs\ВП\mtusi2026lab2
|
||||
```
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
### 1. Запуск проекта
|
||||
|
||||
## Доказательства критериев
|
||||
```powershell
|
||||
docker compose up -d --build
|
||||
docker compose ps
|
||||
```
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
Показать, что запущены три контейнера:
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
- `api` — Java-приложение;
|
||||
- `postgres` — база данных;
|
||||
- `redis` — хранилище сессий.
|
||||
|
||||
## Эксперименты и отказы
|
||||
В лабораторной 1 данные хранились в памяти Java. В лабораторной 2 пользователи,
|
||||
чаты и сообщения перенесены в PostgreSQL, а сессии хранятся в Redis.
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
### 2. Проверка готовности приложения
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
```powershell
|
||||
curl.exe -i http://localhost:8080/health/live
|
||||
curl.exe -i http://localhost:8080/health/ready
|
||||
```
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
Ожидаемый ответ:
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
```json
|
||||
{"status":"ok"}
|
||||
```
|
||||
|
||||
Показать заголовок `X-Request-Id`.
|
||||
|
||||
`health/live` проверяет, что процесс Java работает. `health/ready` дополнительно
|
||||
проверяет доступность PostgreSQL и Redis.
|
||||
|
||||
### 3. Основная автоматическая проверка
|
||||
|
||||
```powershell
|
||||
py -3 tests\smoke.py --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
Ожидаемый результат:
|
||||
|
||||
```text
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
```
|
||||
|
||||
Smoke-тест проверяет регистрацию с паролем, Basic-вход, Bearer-сессию,
|
||||
создание чата, сообщения, пагинацию, ошибки доступа и logout.
|
||||
|
||||
Дополнительные проверки исправлений:
|
||||
|
||||
```powershell
|
||||
py -3 tests\student_tests.py --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
Для оценки 5 дополнительно запускается исследовательский трек:
|
||||
|
||||
```powershell
|
||||
py -3 tests\track2.py
|
||||
```
|
||||
|
||||
### 4. Показать базу PostgreSQL
|
||||
|
||||
```powershell
|
||||
docker compose exec postgres psql -U messenger -d messenger -c "\dt"
|
||||
docker compose exec postgres psql -U messenger -d messenger -c "\d messages"
|
||||
```
|
||||
|
||||
Показать таблицы:
|
||||
|
||||
```text
|
||||
users
|
||||
chats
|
||||
chat_members
|
||||
messages
|
||||
```
|
||||
|
||||
PostgreSQL является основным источником данных. В таблицах есть первичные
|
||||
и внешние ключи. Username уникален. Для истории сообщений создан индекс
|
||||
`(chat_id, created_at, id)`.
|
||||
|
||||
Схема создаётся версионируемой миграцией
|
||||
`src/main/resources/db/migration/V1__init.sql`. Таблица `schema_version`
|
||||
фиксирует применённую версию, поэтому запуск можно повторять без дублирования.
|
||||
|
||||
### 5. Показать Redis и TTL сессии
|
||||
|
||||
Сначала выполнить smoke и найти ключ сессии:
|
||||
|
||||
```powershell
|
||||
docker compose exec redis redis-cli --scan --pattern "session:*"
|
||||
```
|
||||
|
||||
Затем проверить TTL:
|
||||
|
||||
```powershell
|
||||
docker compose exec redis redis-cli ttl session:<вставить_ключ_из_предыдущей_команды>
|
||||
```
|
||||
|
||||
Ожидается положительное число, например:
|
||||
|
||||
```text
|
||||
3590
|
||||
```
|
||||
|
||||
Redis используется не просто для запуска, а для хранения Bearer-сессий.
|
||||
У каждой сессии есть TTL. После истечения TTL токен перестаёт работать.
|
||||
Logout удаляет сессию из Redis.
|
||||
|
||||
### 6. Показать сохранность после перезапуска
|
||||
|
||||
```powershell
|
||||
docker compose restart postgres redis api
|
||||
docker compose ps
|
||||
py -3 tests\smoke.py --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
Обычный restart не удаляет volumes. Поэтому PostgreSQL сохраняет пользователей,
|
||||
чаты и сообщения, а Redis сохраняет действующие сессии, если их TTL ещё не истёк.
|
||||
|
||||
Показать volumes:
|
||||
|
||||
```powershell
|
||||
docker volume ls
|
||||
```
|
||||
|
||||
В `compose.yaml` используются:
|
||||
|
||||
```text
|
||||
pgdata
|
||||
redisdata
|
||||
```
|
||||
|
||||
### 7. Показать отказ Redis
|
||||
|
||||
```powershell
|
||||
docker compose stop redis
|
||||
curl.exe -i http://localhost:8080/health/ready
|
||||
docker compose start redis
|
||||
```
|
||||
|
||||
Ожидается ответ `503` во время остановки Redis.
|
||||
|
||||
При недоступности Redis приложение не принимает запрос без подтверждённой
|
||||
сессии и возвращает ограниченную ошибку. После запуска Redis работа
|
||||
восстанавливается.
|
||||
|
||||
### 8. Показать logout
|
||||
|
||||
Logout проверяется внутри smoke-теста.
|
||||
|
||||
После `DELETE /api/v1/auth/sessions/current` текущая сессия удаляется
|
||||
из Redis. Повторный запрос с тем же Bearer-токеном получает `401`.
|
||||
|
||||
### 9. Что сказать про код
|
||||
|
||||
Показать файл:
|
||||
|
||||
[MessengerApplication.java](src/main/java/ru/mtusi/messenger/MessengerApplication.java)
|
||||
|
||||
Коротко объяснить:
|
||||
|
||||
- `@SpringBootApplication` запускает приложение;
|
||||
- `@RestController` содержит REST-методы;
|
||||
- `JdbcTemplate` выполняет параметризованные SQL-запросы;
|
||||
- SHA-256 сохраняет весь пароль перед `BCryptPasswordEncoder`, чтобы не
|
||||
терять символы после ограничения BCrypt;
|
||||
- `StringRedisTemplate` работает с Redis;
|
||||
- `@Transactional` делает создание чата атомарным;
|
||||
- `@RestControllerAdvice` формирует единый формат ошибок.
|
||||
|
||||
## 10. Исследовательский трек для оценки 5
|
||||
|
||||
Запустить после smoke-тестов:
|
||||
|
||||
```powershell
|
||||
py -3 tests\track2.py
|
||||
```
|
||||
|
||||
Скрипт создаёт 100 000 сообщений с неравномерным распределением по чатам,
|
||||
сравнивает план истории с индексом `messages_history` и принудительным
|
||||
последовательным чтением, измеряет вставку 1000 сообщений с индексом и без
|
||||
него, затем делает `pg_dump` и восстанавливает данные в новый PostgreSQL-
|
||||
контейнер.
|
||||
|
||||
В результате показать:
|
||||
|
||||
- планы `EXPLAIN (ANALYZE, BUFFERS)`;
|
||||
- одинаковое количество сообщений до backup и после восстановления;
|
||||
- восстановление выбранного сообщения;
|
||||
- время backup/восстановления и вставки.
|
||||
|
||||
Один запуск на стенде показал: индексированная выборка — `0.454 ms`,
|
||||
принудительный последовательный план — `41.688 ms`; вставка 1000 сообщений
|
||||
с индексом заняла `485.4 ms`, без индекса — `459.9 ms`. Backup восстановил
|
||||
`302018` из `302018` сообщений за `6.39 s`. Общее количество включает данные
|
||||
предыдущих запусков smoke и трека.
|
||||
|
||||
Вывод: индекс ускоряет выборку истории по `(chat_id, created_at, id)`,
|
||||
но добавляет небольшую стоимость вставки. Backup восстанавливает состояние
|
||||
на момент создания; изменения после backup могут быть потеряны.
|
||||
|
||||
## Ответы на вопросы из README
|
||||
|
||||
### Что подтверждает COMMIT и какие гарантии зависят от настройки durability?
|
||||
|
||||
`COMMIT` означает, что транзакция PostgreSQL успешно завершилась и изменения
|
||||
стали видны другим подключениям. Сохранность после сбоя зависит от постоянного
|
||||
volume PostgreSQL, WAL базы и AOF Redis. Один TTL сам по себе сохранность
|
||||
не гарантирует.
|
||||
|
||||
### Где хранятся сессии и что будет после flush/restart Redis?
|
||||
|
||||
Сессии хранятся в Redis в ключах `session:<token>`. При обычном restart
|
||||
с сохранённым volume действующая сессия может сохраниться. После `FLUSHALL`,
|
||||
удаления volume или истечения TTL токен перестаёт работать и сервер отвечает
|
||||
`401`.
|
||||
|
||||
### Чем аутентификация отличается от доступа к конкретному чату?
|
||||
|
||||
Аутентификация определяет пользователя по Bearer-токену. Доступ к чату
|
||||
проверяется отдельно по таблице `chat_members`. Поэтому действующая сессия
|
||||
не даёт доступ к чужому чату.
|
||||
|
||||
### Почему hash пароля и быстрый checksum имеют разные задачи?
|
||||
|
||||
BCrypt-хеш нужен для защиты пароля: он медленный и усложняет перебор.
|
||||
Быстрый checksum нужен для проверки целостности данных. Для хранения паролей
|
||||
быстрый checksum использовать нельзя, потому что его проще перебирать.
|
||||
|
||||
## Остановка
|
||||
|
||||
Обычная остановка без удаления данных:
|
||||
|
||||
```powershell
|
||||
docker compose down
|
||||
```
|
||||
|
||||
Полный сброс учебных данных:
|
||||
|
||||
```powershell
|
||||
docker compose down -v
|
||||
```
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
# Сервисы приложения, PostgreSQL и Redis запускаются одной командой.
|
||||
services:
|
||||
api:
|
||||
# Сборка Java-приложения из Dockerfile.
|
||||
build: .
|
||||
# Порт приложения: localhost:8080 -> контейнер:8080.
|
||||
ports: ["8080:8080"]
|
||||
# Настройки подключения к PostgreSQL, Redis и срок жизни сессии.
|
||||
environment:
|
||||
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/messenger
|
||||
SPRING_DATASOURCE_USERNAME: messenger
|
||||
SPRING_DATASOURCE_PASSWORD: messenger
|
||||
SPRING_DATA_REDIS_HOST: redis
|
||||
SESSION_TTL_SECONDS: 3600
|
||||
# API запускается после готовности базы и Redis.
|
||||
depends_on:
|
||||
postgres: {condition: service_healthy}
|
||||
redis: {condition: service_healthy}
|
||||
postgres:
|
||||
# PostgreSQL хранит постоянные данные приложения.
|
||||
image: postgres:16.4
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD: messenger
|
||||
# Том сохраняет данные базы после перезапуска контейнера.
|
||||
volumes: [pgdata:/var/lib/postgresql/data]
|
||||
# Проверка готовности PostgreSQL.
|
||||
healthcheck: {test: ["CMD-SHELL","pg_isready -U messenger -d messenger"], interval: 5s, timeout: 3s, retries: 10}
|
||||
redis:
|
||||
# Redis хранит временные Bearer-сессии.
|
||||
image: redis:7.4.1
|
||||
# AOF сохраняет операции Redis на диске.
|
||||
command: redis-server --appendonly yes
|
||||
# Том сохраняет данные Redis после перезапуска.
|
||||
volumes: [redisdata:/data]
|
||||
# Проверка доступности Redis.
|
||||
healthcheck: {test: ["CMD","redis-cli","ping"], interval: 5s, timeout: 3s, retries: 10}
|
||||
# Именованные тома для постоянного хранения данных.
|
||||
volumes: {pgdata: {}, redisdata: {}}
|
||||
@@ -0,0 +1,22 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<parent>
|
||||
<groupId>org.springframework.boot</groupId>
|
||||
<artifactId>spring-boot-starter-parent</artifactId>
|
||||
<version>3.3.5</version>
|
||||
<relativePath/>
|
||||
</parent>
|
||||
<groupId>ru.mtusi</groupId>
|
||||
<artifactId>messenger</artifactId>
|
||||
<version>1.0.0</version>
|
||||
<properties><java.version>21</java.version></properties>
|
||||
<dependencies>
|
||||
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>
|
||||
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency>
|
||||
<dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-crypto</artifactId></dependency>
|
||||
<dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId><scope>runtime</scope></dependency>
|
||||
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>
|
||||
</dependencies>
|
||||
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
|
||||
</project>
|
||||
@@ -0,0 +1 @@
|
||||
docker compose restart postgres redis api
|
||||
Executable
+3
@@ -0,0 +1,3 @@
|
||||
#!/bin/sh
|
||||
set -e
|
||||
docker compose restart postgres redis api
|
||||
@@ -0,0 +1,375 @@
|
||||
package ru.mtusi.messenger;
|
||||
|
||||
import jakarta.servlet.FilterChain;
|
||||
import jakarta.servlet.ServletException;
|
||||
import jakarta.servlet.http.*;
|
||||
import org.springframework.boot.*;
|
||||
import org.springframework.boot.autoconfigure.SpringBootApplication;
|
||||
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
|
||||
import org.springframework.context.annotation.DependsOn;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.core.io.ClassPathResource;
|
||||
import com.fasterxml.jackson.databind.JsonNode;
|
||||
import org.springframework.dao.DuplicateKeyException;
|
||||
import org.springframework.dao.DataAccessException;
|
||||
import org.springframework.data.redis.core.StringRedisTemplate;
|
||||
import org.springframework.http.*;
|
||||
import org.springframework.jdbc.core.JdbcTemplate;
|
||||
import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
|
||||
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
|
||||
import org.springframework.web.bind.annotation.*;
|
||||
import org.springframework.web.filter.OncePerRequestFilter;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
import org.springframework.http.converter.HttpMessageNotReadableException;
|
||||
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import com.fasterxml.jackson.databind.MapperFeature;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.security.MessageDigest;
|
||||
import java.security.SecureRandom;
|
||||
import java.time.*;
|
||||
import java.util.*;
|
||||
import java.util.Base64;
|
||||
|
||||
// Главная аннотация Spring Boot: включает запуск приложения и автоматическую настройку.
|
||||
@SpringBootApplication
|
||||
public class MessengerApplication {
|
||||
// Метод main является точкой входа в Java-программу.
|
||||
// Здесь Spring Boot запускает встроенный HTTP-сервер.
|
||||
public static void main(String[] args) {
|
||||
// Передаём главный класс и аргументы командной строки Spring Boot.
|
||||
SpringApplication.run(MessengerApplication.class, args);
|
||||
}
|
||||
|
||||
// @Bean регистрирует возвращаемый объект в контейнере Spring.
|
||||
// BCrypt хранит пароль в виде хеша, поэтому исходный пароль не попадает в базу.
|
||||
@Bean
|
||||
BCryptPasswordEncoder passwordEncoder() {
|
||||
// Возвращаем BCrypt-кодировщик, который Spring передаст контроллеру.
|
||||
return new BCryptPasswordEncoder();
|
||||
}
|
||||
|
||||
// Отключаем автоматическое превращение чисел в строки при чтении JSON.
|
||||
@Bean
|
||||
Jackson2ObjectMapperBuilderCustomizer strictJson() {
|
||||
return builder -> builder.featuresToDisable(MapperFeature.ALLOW_COERCION_OF_SCALARS);
|
||||
}
|
||||
|
||||
// Выполняем версионируемую миграцию до создания REST API.
|
||||
@Bean(name="migration")
|
||||
Object migration(javax.sql.DataSource dataSource) {
|
||||
new ResourceDatabasePopulator(new ClassPathResource("db/migration/V1__init.sql")).execute(dataSource);
|
||||
return new Object();
|
||||
}
|
||||
|
||||
// @Bean регистрирует фильтр в контейнере Spring.
|
||||
// Фильтр добавляет общий идентификатор каждому HTTP-ответу.
|
||||
@Bean OncePerRequestFilter requestId() {
|
||||
return new OncePerRequestFilter() {
|
||||
// Метод фильтра вызывается для каждого HTTP-запроса.
|
||||
protected void doFilterInternal(HttpServletRequest r, HttpServletResponse s, FilterChain c)
|
||||
throws ServletException, IOException {
|
||||
// Создаём уникальный идентификатор текущего запроса.
|
||||
String id=UUID.randomUUID().toString();
|
||||
// Добавляем идентификатор в HTTP-ответ.
|
||||
s.setHeader("X-Request-Id", id);
|
||||
// Сохраняем тот же идентификатор для обработчика ошибок.
|
||||
r.setAttribute("requestId", id);
|
||||
// Передаём запрос дальше по цепочке Spring.
|
||||
c.doFilter(r, s);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Эти record-классы описывают JSON-модели ответов и запросов.
|
||||
// Публичная модель пользователя без пароля.
|
||||
record User(UUID id, String username, String display_name, Instant created_at) {}
|
||||
// Модель чата со списком участников.
|
||||
record Chat(UUID id, String title, List<UUID> member_ids, Instant created_at) {}
|
||||
// Модель сообщения с автором и временем создания.
|
||||
record Message(UUID id, UUID chat_id, UUID sender_id, String text, Instant created_at) {}
|
||||
// Универсальная модель страницы списка.
|
||||
record Page<T>(List<T> items, String next_cursor) {}
|
||||
// Ответ успешного входа с Bearer-токеном.
|
||||
record Session(String token, String token_type, Instant expires_at, User user) {}
|
||||
// Тело запроса регистрации.
|
||||
record UserIn(JsonNode username, JsonNode display_name, JsonNode password) {}
|
||||
// Тело запроса создания чата.
|
||||
record ChatIn(JsonNode title, List<UUID> member_ids) {}
|
||||
// Тело запроса отправки сообщения.
|
||||
record MessageIn(JsonNode text) {}
|
||||
// Поля внутренней ошибки API.
|
||||
record Error(String code, String message, String request_id) {}
|
||||
// Обёртка, требуемая форматом JSON ошибки.
|
||||
record ErrorBody(Error error) {}
|
||||
|
||||
// Исключение хранит HTTP-статус и безопасный код ошибки.
|
||||
static class ApiException extends RuntimeException {
|
||||
// HTTP-статус, который будет отправлен клиенту.
|
||||
final HttpStatus status;
|
||||
// Короткий код ошибки для программы-клиента.
|
||||
final String code;
|
||||
ApiException(HttpStatus s, String c, String m) {
|
||||
// Сохраняем текст сообщения в стандартном RuntimeException.
|
||||
super(m);
|
||||
status=s;
|
||||
code=c;
|
||||
}
|
||||
}
|
||||
|
||||
// @RestController объединяет @Controller и @ResponseBody.
|
||||
// Методы этого класса принимают HTTP-запросы и возвращают JSON.
|
||||
@DependsOn("migration")
|
||||
@RestController
|
||||
static class Api {
|
||||
// JdbcTemplate работает с PostgreSQL, RedisTemplate — с Redis-сессиями.
|
||||
// JdbcTemplate отправляет SQL-запросы в PostgreSQL.
|
||||
final JdbcTemplate db;
|
||||
// StringRedisTemplate работает со строковыми ключами Redis.
|
||||
final StringRedisTemplate redis;
|
||||
// BCryptPasswordEncoder проверяет и хеширует пароли.
|
||||
final BCryptPasswordEncoder encoder;
|
||||
// Генератор создаёт 32 случайных байта для каждой сессии.
|
||||
final SecureRandom random = new SecureRandom();
|
||||
// TTL можно уменьшить через переменную окружения для проверки expiry.
|
||||
final long ttl = Long.parseLong(System.getenv().getOrDefault("SESSION_TTL_SECONDS", "3600"));
|
||||
Api(JdbcTemplate d, StringRedisTemplate r, BCryptPasswordEncoder e) {
|
||||
// Сохраняем зависимости, созданные Spring Boot.
|
||||
db=d;
|
||||
redis=r;
|
||||
encoder=e;
|
||||
}
|
||||
// Метод проверяет доступность PostgreSQL тестовым запросом.
|
||||
void dbOk() {
|
||||
try {
|
||||
// Простой запрос проверяет соединение с PostgreSQL.
|
||||
db.queryForObject("select 1", Integer.class);
|
||||
} catch (Exception e) {
|
||||
// Внутреннюю ошибку базы не показываем клиенту.
|
||||
throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","database is unavailable");
|
||||
}
|
||||
}
|
||||
// Метод проверяет Bearer-токен и возвращает UUID пользователя.
|
||||
UUID auth(HttpServletRequest req) {
|
||||
// Читаем заголовок авторизации из HTTP-запроса.
|
||||
String h=req.getHeader("Authorization");
|
||||
// Защищённые методы принимают только Bearer-схему.
|
||||
if (h==null || !h.startsWith("Bearer ")) throw unauth();
|
||||
// В Redis хранится связь токена с UUID пользователя.
|
||||
try { String v=redis.opsForValue().get("session:"+h.substring(7)); if(v==null) throw unauth(); return UUID.fromString(v); }
|
||||
catch (ApiException e) { throw e; } catch (Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
|
||||
}
|
||||
ApiException unauth() { return new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","valid Bearer session required"); }
|
||||
// Загружаем пользователя по UUID из PostgreSQL.
|
||||
// Метод ищет пользователя в PostgreSQL по его UUID.
|
||||
User user(UUID id) {
|
||||
return db.query("select id,username,display_name,created_at from users where id=?", rs -> rs.next()
|
||||
? new User(rs.getObject(1,UUID.class),rs.getString(2),rs.getString(3),rs.getTimestamp(4).toInstant()) : null, id);
|
||||
}
|
||||
// Метод проверяет, состоит ли пользователь в выбранном чате.
|
||||
boolean member(UUID chat, UUID user) {
|
||||
// Пользователь должен состоять в чате, иначе ресурс для него скрыт.
|
||||
return Boolean.TRUE.equals(db.queryForObject("select exists(select 1 from chat_members where chat_id=? and user_id=?)",Boolean.class,chat,user));
|
||||
}
|
||||
// Загружает один чат и его участников напрямую по идентификатору.
|
||||
Chat chatById(UUID id) {
|
||||
return db.query("select id,title,created_at from chats where id=?",rs -> rs.next()
|
||||
? new Chat(rs.getObject(1,UUID.class),rs.getString(2),
|
||||
db.query("select user_id from chat_members where chat_id=?",(z,k)->z.getObject(1,UUID.class),id),
|
||||
rs.getTimestamp(3).toInstant()) : null,id);
|
||||
}
|
||||
// Считает символы как Unicode code points, а не как UTF-16 char.
|
||||
int codePointLength(String value) {
|
||||
return value.codePointCount(0,value.length());
|
||||
}
|
||||
// Возвращает значение только если JSON-поле действительно является строкой.
|
||||
String string(JsonNode value) { return value!=null && value.isTextual()?value.textValue():null; }
|
||||
// PostgreSQL не хранит нулевой байт, поэтому заменяем его безопасным символом.
|
||||
String databaseText(String value) { return value==null?null:value.replace('\0','\uFFFD'); }
|
||||
// Проверяет обязательную непустую строку и её максимальную длину.
|
||||
boolean text(String value, int max) { return value!=null && !value.isBlank() && codePointLength(value)<=max; }
|
||||
// Предварительный SHA-256 сохраняет весь пароль перед ограниченным BCrypt.
|
||||
String passwordValue(String value) {
|
||||
try { return Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8))); }
|
||||
catch (Exception e) { throw new IllegalStateException("password hashing is unavailable",e); }
|
||||
}
|
||||
|
||||
// Готовность проверяет не только Java-процесс, но и его зависимости.
|
||||
// @GetMapping связывает GET-запрос с Java-методом.
|
||||
@GetMapping({"/health/live","/health/ready"})
|
||||
// Для ready дополнительно проверяем PostgreSQL и Redis.
|
||||
// Метод возвращает JSON со статусом приложения.
|
||||
Map<String,String> health(HttpServletRequest r) { if (r.getRequestURI().endsWith("ready")) { dbOk(); try { redis.hasKey("health"); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); } } return Map.of("status","ok"); }
|
||||
// @PostMapping связывает POST-запрос с методом регистрации.
|
||||
@PostMapping("/api/v1/users")
|
||||
// @RequestBody преобразует JSON-тело запроса в объект UserIn.
|
||||
ResponseEntity<User> register(@RequestBody UserIn in) {
|
||||
String username=in==null?null:string(in.username());
|
||||
String displayName=in==null?null:string(in.display_name());
|
||||
String password=in==null?null:string(in.password());
|
||||
// До запроса в базу проверяем формат обязательных полей.
|
||||
if(username==null || !username.matches("[a-z0-9_]{3,32}") || !text(displayName,100) || password==null || password.isBlank() || codePointLength(password)<12 || codePointLength(password)>128) bad();
|
||||
displayName=databaseText(displayName);
|
||||
// Создаём UUID пользователя и фиксируем время регистрации.
|
||||
UUID id=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
|
||||
// Значения передаются параметрами, а не склеиваются со строкой SQL.
|
||||
try { db.update("insert into users values(?,?,?,?,?)",id,username,displayName,encoder.encode(passwordValue(password)),java.sql.Timestamp.from(now)); }
|
||||
// Уникальное ограничение username превращаем в понятный ответ 409.
|
||||
catch(DuplicateKeyException e) { throw new ApiException(HttpStatus.CONFLICT,"conflict","username is already used"); }
|
||||
// Возвращаем созданного пользователя без пароля.
|
||||
return ResponseEntity.status(201).body(new User(id,username,displayName,now));
|
||||
}
|
||||
// POST-метод входа проверяет Basic-логин и создаёт Bearer-сессию.
|
||||
@PostMapping("/api/v1/auth/sessions")
|
||||
// HttpServletRequest позволяет прочитать заголовок Authorization.
|
||||
ResponseEntity<Session> login(HttpServletRequest req) {
|
||||
// Читаем Basic-заголовок, который используется только при входе.
|
||||
String h=req.getHeader("Authorization");
|
||||
if(h==null || !h.startsWith("Basic ")) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","Basic authentication required"); }
|
||||
// Basic используется только для входа, после него клиент получает Bearer-токен.
|
||||
String[] p; try { p=new String(Base64.getDecoder().decode(h.substring(6)),StandardCharsets.UTF_8).split(":",2); } catch(Exception e) { p=new String[0]; }
|
||||
// Получаем BCrypt-хеш пользователя из PostgreSQL.
|
||||
String hash=p.length==2 ? db.query("select password_hash from users where username=?",rs -> rs.next()?rs.getString(1):null,p[0]) : null;
|
||||
// Сравниваем введённый пароль с сохранённым хешем.
|
||||
if(p.length!=2 || hash==null || codePointLength(p[1])<12 || codePointLength(p[1])>128 || !encoder.matches(passwordValue(p[1]),hash)) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","invalid credentials"); }
|
||||
// После успешной проверки загружаем полную модель пользователя.
|
||||
User u=user(db.queryForObject("select id from users where username=?",UUID.class,p[0]));
|
||||
// Генерируем непрозрачный случайный токен сессии.
|
||||
byte[] secret=new byte[32]; random.nextBytes(secret);
|
||||
String token=Base64.getUrlEncoder().withoutPadding().encodeToString(secret);
|
||||
// Вычисляем момент, когда сессия перестанет действовать.
|
||||
Instant exp=Instant.now().plusSeconds(ttl);
|
||||
// Сессия автоматически удалится из Redis после окончания TTL.
|
||||
try { redis.opsForValue().set("session:"+token,u.id().toString(),Duration.ofSeconds(ttl)); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
|
||||
return ResponseEntity.status(201).body(new Session(token,"Bearer",exp,u));
|
||||
}
|
||||
// @DeleteMapping связывает DELETE-запрос с удалением сессии.
|
||||
// Logout сразу удаляет текущий токен из Redis.
|
||||
@DeleteMapping("/api/v1/auth/sessions/current") ResponseEntity<Void> logout(HttpServletRequest r) { auth(r); redis.delete("session:"+r.getHeader("Authorization").substring(7)); return ResponseEntity.noContent().build(); }
|
||||
// GET-запрос возвращает данные текущего авторизованного пользователя.
|
||||
@GetMapping("/api/v1/users/me") User me(HttpServletRequest r) { return user(auth(r)); }
|
||||
// @Transactional объединяет несколько SQL-команд в одну транзакцию.
|
||||
// Если одна команда завершится ошибкой, изменения откатываются.
|
||||
// Вставка чата и всех его участников выполняется как одна транзакция.
|
||||
@Transactional
|
||||
// POST-запрос создаёт новый чат.
|
||||
@PostMapping("/api/v1/chats") ResponseEntity<Chat> createChat(@RequestBody ChatIn in,HttpServletRequest r) {
|
||||
// Владелец чата определяется по Bearer-сессии.
|
||||
String title=in==null?null:string(in.title());
|
||||
UUID owner=auth(r); if(!text(title,100)||in.member_ids()==null||in.member_ids().isEmpty()||in.member_ids().size()>100||new HashSet<>(in.member_ids()).size()!=in.member_ids().size()||!in.member_ids().contains(owner)) bad();
|
||||
// Проверяем существование каждого участника.
|
||||
for(UUID id:in.member_ids()) if(user(id)==null) bad();
|
||||
// ID и время создаются сервером.
|
||||
UUID id=UUID.randomUUID(); Instant now=Instant.now();
|
||||
// Записываем чат и участников в одной транзакции.
|
||||
title=databaseText(title);
|
||||
db.update("insert into chats values(?,?,?)",id,title,java.sql.Timestamp.from(now)); for(UUID m:in.member_ids()) db.update("insert into chat_members values(?,?)",id,m);
|
||||
// Возвращаем созданную модель чата.
|
||||
return ResponseEntity.status(201).body(new Chat(id,title,in.member_ids(),now));
|
||||
}
|
||||
// GET-запрос получает список чатов текущего пользователя.
|
||||
@GetMapping("/api/v1/chats")
|
||||
Page<Chat> chats(HttpServletRequest r) {
|
||||
// Определяем пользователя, для которого строится список.
|
||||
UUID u=auth(r);
|
||||
String cursor=r.getParameter("cursor");
|
||||
int limit=parseLimit(r.getParameter("limit"));
|
||||
// Запрашиваем только чаты, где пользователь является участником.
|
||||
String sql="select c.id,c.title,c.created_at from chats c join chat_members m on m.chat_id=c.id where m.user_id=? ";
|
||||
List<Object> args=new ArrayList<>(List.of(u));
|
||||
if(cursor!=null) {
|
||||
try {
|
||||
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
|
||||
if(p.length!=2) bad();
|
||||
sql+="and (c.created_at,c.id)>(?,?) ";
|
||||
args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[0]).toInstant()));
|
||||
args.add(UUID.fromString(p[1]));
|
||||
} catch(Exception e) { if(e instanceof ApiException a) throw a; bad(); }
|
||||
}
|
||||
sql+="order by c.created_at,c.id limit ?";
|
||||
args.add(limit+1);
|
||||
List<Chat> x=db.query(sql,(rs,n)->new Chat(rs.getObject(1,UUID.class),rs.getString(2),db.query("select user_id from chat_members where chat_id=?", (z,k)->z.getObject(1,UUID.class),rs.getObject(1)),rs.getTimestamp(3).toInstant()),args.toArray());
|
||||
String next=x.size()>limit?Base64.getUrlEncoder().withoutPadding().encodeToString((x.get(limit-1).created_at()+"|"+x.get(limit-1).id()).getBytes(StandardCharsets.UTF_8)):null;
|
||||
return new Page<>(x.subList(0,Math.min(limit,x.size())),next);
|
||||
}
|
||||
// {id} является переменной частью URL.
|
||||
@GetMapping("/api/v1/chats/{id}")
|
||||
// @PathVariable получает id из адреса запроса.
|
||||
Chat chat(@PathVariable UUID id,HttpServletRequest r) {
|
||||
// Сначала проверяем токен и членство в чате.
|
||||
UUID u=auth(r); if(!member(id,u)) throw notFound();
|
||||
// Загружаем чат напрямую, поэтому поздние записи не зависят от первой страницы списка.
|
||||
Chat result=chatById(id);
|
||||
if(result==null) throw notFound();
|
||||
return result;
|
||||
}
|
||||
// POST-запрос добавляет сообщение в выбранный чат.
|
||||
// @PathVariable получает id чата, а @RequestBody — текст из JSON.
|
||||
@PostMapping("/api/v1/chats/{id}/messages") ResponseEntity<Message> message(@PathVariable UUID id,@RequestBody MessageIn in,HttpServletRequest r) {
|
||||
// Автор сообщения берётся из сессии, а не из тела запроса.
|
||||
String messageText=databaseText(in==null?null:string(in.text()));
|
||||
UUID u=auth(r); if(!member(id,u)) throw notFound(); if(!text(messageText,4000)) bad();
|
||||
// Сервер создаёт ID и время сообщения.
|
||||
UUID mid=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS); db.update("insert into messages values(?,?,?,?,?)",mid,id,u,messageText,java.sql.Timestamp.from(now)); return ResponseEntity.status(201).body(new Message(mid,id,u,messageText,now));
|
||||
}
|
||||
// GET-запрос возвращает историю сообщений с cursor-пагинацией.
|
||||
// @RequestParam получает limit и cursor из параметров URL.
|
||||
@GetMapping("/api/v1/chats/{id}/messages") Page<Message> messages(@PathVariable UUID id,@RequestParam(required=false) String limit,@RequestParam(required=false) String cursor,HttpServletRequest r) {
|
||||
// Историю может читать только участник чата.
|
||||
UUID u=auth(r); if(!member(id,u)) throw notFound(); int pageLimit=parseLimit(limit);
|
||||
// Начинаем параметризованный запрос истории.
|
||||
String sql="select id,chat_id,sender_id,text,created_at from messages where chat_id=? ";
|
||||
// Список параметров передаётся в JdbcTemplate отдельно от SQL.
|
||||
List<Object> args=new ArrayList<>(List.of(id));
|
||||
if(cursor!=null) {
|
||||
try {
|
||||
// Cursor хранит время и ID последнего сообщения предыдущей страницы.
|
||||
// Декодируем cursor из Base64 в обычную строку.
|
||||
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
|
||||
if(p.length!=3 || !id.equals(UUID.fromString(p[0]))) bad();
|
||||
// Добавляем условие keyset-пагинации после последнего сообщения.
|
||||
sql+="and (created_at,id)>(?,?) "; args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[1]).toInstant())); args.add(UUID.fromString(p[2]));
|
||||
} catch(Exception e) { bad(); }
|
||||
}
|
||||
// Сортируем историю и берём одну запись сверх лимита для следующего cursor.
|
||||
sql+="order by created_at,id limit ?"; args.add(pageLimit+1);
|
||||
// Выполняем запрос и превращаем строки базы в объекты Message.
|
||||
List<Message> x=db.query(sql,(rs,n)->new Message(rs.getObject(1,UUID.class),rs.getObject(2,UUID.class),rs.getObject(3,UUID.class),rs.getString(4),rs.getTimestamp(5).toInstant()),args.toArray());
|
||||
// Если запись сверх лимита есть, кодируем её позицию как следующий cursor.
|
||||
String next=x.size()>pageLimit?Base64.getUrlEncoder().withoutPadding().encodeToString((id+"|"+x.get(pageLimit-1).created_at()+"|"+x.get(pageLimit-1).id()).getBytes(StandardCharsets.UTF_8)):null; return new Page<>(x.subList(0,Math.min(pageLimit,x.size())),next);
|
||||
}
|
||||
// Преобразует limit списка чатов в число и проверяет диапазон.
|
||||
int parseLimit(String value) { try { int limit=value==null?50:Integer.parseInt(value); if(limit<1||limit>100) bad(); return limit; } catch(NumberFormatException e) { bad(); return 0; } }
|
||||
// Формируем ошибку, не раскрывая наличие чужого объекта.
|
||||
ApiException notFound(){return new ApiException(HttpStatus.NOT_FOUND,"not_found","object not found");}
|
||||
// Формируем общую ошибку некорректного запроса.
|
||||
void bad(){throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","invalid request");}
|
||||
}
|
||||
// @RestControllerAdvice применяет обработчики ко всем REST-контроллерам.
|
||||
// Благодаря этому ошибки возвращаются в одном формате JSON.
|
||||
@RestControllerAdvice static class Errors {
|
||||
// Все ошибки API приводятся к одному JSON-формату.
|
||||
// @ExceptionHandler связывает тип исключения с методом обработки.
|
||||
// Здесь обрабатываются специально созданные ошибки API.
|
||||
@ExceptionHandler(ApiException.class) ResponseEntity<ErrorBody> api(ApiException e,HttpServletRequest r){
|
||||
// Создаём заголовки ответа с ошибкой.
|
||||
HttpHeaders h=new HttpHeaders();
|
||||
if(e.status==HttpStatus.UNAUTHORIZED) h.set("WWW-Authenticate",r.getRequestURI().equals("/api/v1/auth/sessions")?"Basic realm=\"messenger\", charset=\"UTF-8\"":"Bearer realm=\"messenger\"");
|
||||
// Возвращаем статус, заголовки и единое тело ошибки.
|
||||
return ResponseEntity.status(e.status).headers(h).body(new ErrorBody(new Error(e.code,e.getMessage(),id(r))));
|
||||
}
|
||||
// Неожиданные исключения превращаем в безопасный ответ 500.
|
||||
// Этот обработчик является запасным для неожиданных исключений.
|
||||
@ExceptionHandler(Exception.class) ResponseEntity<ErrorBody> other(Exception e,HttpServletRequest r){ LoggerFactory.getLogger(Errors.class).error("request failed",e); return ResponseEntity.status(500).body(new ErrorBody(new Error("internal_error","internal server error",id(r)))); }
|
||||
// Неправильный JSON считается ошибкой входных данных клиента.
|
||||
// Этот обработчик ловит неправильный или повреждённый JSON.
|
||||
@ExceptionHandler(HttpMessageNotReadableException.class) ResponseEntity<ErrorBody> malformed(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
|
||||
// Ошибка преобразования UUID или числового параметра означает неверный запрос.
|
||||
@ExceptionHandler(MethodArgumentTypeMismatchException.class) ResponseEntity<ErrorBody> mismatch(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
|
||||
// Ошибка PostgreSQL возвращается как временная недоступность зависимости.
|
||||
@ExceptionHandler(DataAccessException.class) ResponseEntity<ErrorBody> database(DataAccessException e,HttpServletRequest r){ return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(new ErrorBody(new Error("unavailable","database is unavailable",id(r)))); }
|
||||
// Получаем ID запроса, который добавил фильтр.
|
||||
String id(HttpServletRequest r){ return String.valueOf(r.getAttribute("requestId")); }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
server.address=${APP_HOST:0.0.0.0}
|
||||
server.port=${APP_PORT:8080}
|
||||
server.shutdown=graceful
|
||||
spring.lifecycle.timeout-per-shutdown-phase=10s
|
||||
spring.jackson.deserialization.fail-on-unknown-properties=true
|
||||
spring.datasource.url=${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/messenger}
|
||||
spring.datasource.username=${SPRING_DATASOURCE_USERNAME:messenger}
|
||||
spring.datasource.password=${SPRING_DATASOURCE_PASSWORD:messenger}
|
||||
spring.datasource.hikari.maximum-pool-size=10
|
||||
spring.datasource.hikari.connection-timeout=3000
|
||||
spring.datasource.hikari.connection-init-sql=SET statement_timeout = '3000'; SET lock_timeout = '1000'
|
||||
spring.data.redis.host=${SPRING_DATA_REDIS_HOST:localhost}
|
||||
spring.data.redis.port=${SPRING_DATA_REDIS_PORT:6379}
|
||||
spring.data.redis.timeout=2s
|
||||
spring.sql.init.mode=never
|
||||
spring.jackson.mapper.allow-coercion-of-scalars=false
|
||||
@@ -0,0 +1,27 @@
|
||||
-- Version 1 creates the complete messenger schema.
|
||||
CREATE TABLE IF NOT EXISTS schema_version (
|
||||
version VARCHAR(20) PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id UUID PRIMARY KEY, username VARCHAR(32) UNIQUE NOT NULL,
|
||||
display_name VARCHAR(100) NOT NULL, password_hash VARCHAR(100) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id UUID REFERENCES users(id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id UUID PRIMARY KEY, chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id UUID REFERENCES users(id), text VARCHAR(4000) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS messages_history ON messages(chat_id, created_at, id);
|
||||
INSERT INTO schema_version(version, applied_at)
|
||||
VALUES ('V1__init', now())
|
||||
ON CONFLICT (version) DO NOTHING;
|
||||
@@ -0,0 +1,61 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Focused regression checks for the lab2 security and pagination fixes."""
|
||||
import base64
|
||||
import uuid
|
||||
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Student regression checks')
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, _, chat = c.bootstrap()
|
||||
|
||||
long_password = 'a' * 72 + 'x'
|
||||
username = 'edge_' + uuid.uuid4().hex[:12]
|
||||
registration = {
|
||||
'username': username,
|
||||
'display_name': 'Edge',
|
||||
'password': long_password,
|
||||
}
|
||||
c.call('POST', '/api/v1/users', 201, body=registration, schema='User')
|
||||
wrong = base64.b64encode((username + ':' + 'a' * 72 + 'y').encode()).decode()
|
||||
c.call('POST', '/api/v1/auth/sessions', 401,
|
||||
headers={'Authorization': 'Basic ' + wrong})
|
||||
|
||||
emoji = chr(0x1F600)
|
||||
unicode_user = {
|
||||
'username': 'unicode_' + uuid.uuid4().hex[:8],
|
||||
'display_name': emoji * 100,
|
||||
'password': emoji * 65 + 'a',
|
||||
}
|
||||
c.call('POST', '/api/v1/users', 201, body=unicode_user, schema='User')
|
||||
numeric = {'username': 'number_' + uuid.uuid4().hex[:8],
|
||||
'display_name': 123, 'password': 'password123456'}
|
||||
c.call('POST', '/api/v1/users', 400, body=numeric)
|
||||
|
||||
for number in range(5):
|
||||
c.call('POST', '/api/v1/chats', 201,
|
||||
body={'title': 'Page ' + str(number), 'member_ids': [alice['id'], bob['id']]},
|
||||
actor=alice, schema='Chat')
|
||||
page = c.call('GET', '/api/v1/chats?limit=1', actor=alice, schema='ChatPage')['json']
|
||||
check(page['next_cursor'] is not None, 'chat list ignored limit')
|
||||
c.call('GET', '/api/v1/chats?limit=0', 400, actor=alice)
|
||||
c.call('GET', '/api/v1/chats?limit=abc', 400, actor=alice)
|
||||
|
||||
other = c.call('POST', '/api/v1/chats', 201,
|
||||
body={'title': 'Other', 'member_ids': [alice['id'], bob['id']]},
|
||||
actor=alice, schema='Chat')['json']
|
||||
c.message(alice, chat, 'first')
|
||||
c.message(alice, chat, 'second')
|
||||
history = c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=1',
|
||||
actor=alice, schema='MessagePage')['json']
|
||||
c.call('GET', '/api/v1/chats/' + other['id'] + '/messages?limit=1&cursor=' +
|
||||
history['next_cursor'], 400, actor=alice)
|
||||
c.call('GET', '/api/v1/chats/not-a-uuid', 400, actor=alice)
|
||||
|
||||
print('PASS: student regression checks')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
+145
@@ -0,0 +1,145 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Repeatable level-5 track: query plans, write cost and PostgreSQL restore."""
|
||||
import csv
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import tempfile
|
||||
import time
|
||||
import uuid
|
||||
|
||||
|
||||
COMPOSE = ['docker', 'compose']
|
||||
RESTORE = 'mtusi2026lab2-track2-restore'
|
||||
|
||||
|
||||
def run(command, data=None, check=True):
|
||||
result = subprocess.run(command, input=data, capture_output=True, check=check)
|
||||
return result.stdout.decode('utf-8', errors='replace')
|
||||
|
||||
|
||||
def psql(sql, database='messenger'):
|
||||
return run(COMPOSE + ['exec', '-T', 'postgres', 'psql', '-U', 'messenger',
|
||||
'-d', database, '-At', '-c', sql]).strip()
|
||||
|
||||
|
||||
def explain(sql):
|
||||
output = psql(sql)
|
||||
return json.loads(output[output.index('['):])[0]
|
||||
|
||||
|
||||
def copy_messages(rows):
|
||||
data = io.StringIO(newline='')
|
||||
writer = csv.writer(data, lineterminator='\n')
|
||||
writer.writerows(rows)
|
||||
run(COMPOSE + ['exec', '-T', 'postgres', 'psql', '-U', 'messenger',
|
||||
'-d', 'messenger', '-c',
|
||||
'COPY messages(id, chat_id, sender_id, text, created_at) FROM STDIN WITH (FORMAT csv)'],
|
||||
data.getvalue().encode())
|
||||
|
||||
|
||||
def restore_psql(sql):
|
||||
return run(['docker', 'exec', '-i', RESTORE, 'psql', '-U', 'postgres',
|
||||
'-d', 'messenger', '-At', '-c', sql]).strip()
|
||||
|
||||
|
||||
def main():
|
||||
suffix = uuid.uuid4().hex[:10]
|
||||
user_id = str(uuid.uuid4())
|
||||
chat_id = str(uuid.uuid4())
|
||||
write_chat_id = str(uuid.uuid4())
|
||||
setup = f"""
|
||||
INSERT INTO users(id, username, display_name, password_hash, created_at)
|
||||
VALUES ('{user_id}', 'track2_{suffix}', 'Track 2', 'not-used', now());
|
||||
INSERT INTO chats(id, title, created_at)
|
||||
VALUES ('{chat_id}', 'Track 2 large chat', now()),
|
||||
('{write_chat_id}', 'Track 2 write benchmark', now());
|
||||
INSERT INTO chat_members(chat_id, user_id)
|
||||
VALUES ('{chat_id}', '{user_id}'), ('{write_chat_id}', '{user_id}');
|
||||
"""
|
||||
psql(setup)
|
||||
|
||||
print('Generating 100000 messages with a skewed chat distribution...')
|
||||
csv_data = io.StringIO(newline='')
|
||||
writer = csv.writer(csv_data, lineterminator='\n')
|
||||
for number in range(100_000):
|
||||
message_chat = chat_id if number < 90_000 else write_chat_id
|
||||
writer.writerow([str(uuid.uuid4()), message_chat, user_id,
|
||||
'track2 message ' + str(number),
|
||||
f'2026-01-01 00:00:{number % 60:02d}.000000+00'])
|
||||
run(COMPOSE + ['exec', '-T', 'postgres', 'psql', '-U', 'messenger',
|
||||
'-d', 'messenger', '-c',
|
||||
'COPY messages(id, chat_id, sender_id, text, created_at) FROM STDIN WITH (FORMAT csv)'],
|
||||
csv_data.getvalue().encode())
|
||||
|
||||
query = ("SELECT id, chat_id, sender_id, text, created_at FROM messages "
|
||||
f"WHERE chat_id = '{chat_id}' ORDER BY created_at, id LIMIT 50")
|
||||
indexed = explain('EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ' + query)
|
||||
without_index = explain(
|
||||
"SET enable_indexscan=off; SET enable_bitmapscan=off; "
|
||||
"EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) " + query)
|
||||
|
||||
print('Indexed plan:')
|
||||
print(json.dumps(indexed, ensure_ascii=False))
|
||||
print('Sequential-scan comparison:')
|
||||
print(json.dumps(without_index, ensure_ascii=False))
|
||||
|
||||
rows = [(str(uuid.uuid4()), write_chat_id, user_id,
|
||||
'write benchmark ' + str(number), '2026-02-01 00:00:00+00')
|
||||
for number in range(1_000)]
|
||||
started = time.perf_counter()
|
||||
copy_messages(rows)
|
||||
with_index_ms = (time.perf_counter() - started) * 1000
|
||||
psql('DROP INDEX messages_history')
|
||||
rows = [(str(uuid.uuid4()), write_chat_id, user_id,
|
||||
'write without index ' + str(number), '2026-02-02 00:00:00+00')
|
||||
for number in range(1_000)]
|
||||
started = time.perf_counter()
|
||||
copy_messages(rows)
|
||||
without_index_ms = (time.perf_counter() - started) * 1000
|
||||
psql('CREATE INDEX messages_history ON messages(chat_id, created_at, id)')
|
||||
print(f'1000 inserts with index: {with_index_ms:.1f} ms')
|
||||
print(f'1000 inserts without index: {without_index_ms:.1f} ms')
|
||||
|
||||
backup_path = os.path.join(tempfile.gettempdir(), 'mtusi2026lab2-track2.sql')
|
||||
backup = run(COMPOSE + ['exec', '-T', 'postgres', 'pg_dump', '-U',
|
||||
'messenger', '-d', 'messenger'])
|
||||
with open(backup_path, 'w', encoding='utf-8', newline='') as file:
|
||||
file.write(backup)
|
||||
before = psql('SELECT count(*) FROM messages')
|
||||
selected_id = psql(f"SELECT id FROM messages WHERE chat_id='{chat_id}' ORDER BY id LIMIT 1")
|
||||
|
||||
try:
|
||||
run(['docker', 'rm', '-f', RESTORE], check=False)
|
||||
run(['docker', 'run', '-d', '--name', RESTORE, '-e',
|
||||
'POSTGRES_PASSWORD=restore', '-e', 'POSTGRES_DB=messenger',
|
||||
'postgres:16.4'])
|
||||
for _ in range(30):
|
||||
try:
|
||||
run(['docker', 'exec', RESTORE, 'pg_isready', '-U', 'postgres'])
|
||||
break
|
||||
except subprocess.CalledProcessError:
|
||||
time.sleep(1)
|
||||
restore_start = time.perf_counter()
|
||||
run(['docker', 'exec', '-i', RESTORE, 'psql', '-U', 'postgres',
|
||||
'-d', 'messenger'], backup.encode())
|
||||
restore_seconds = time.perf_counter() - restore_start
|
||||
after = restore_psql('SELECT count(*) FROM messages')
|
||||
restored_id = restore_psql(
|
||||
f"SELECT id FROM messages WHERE id='{selected_id}'")
|
||||
print(f'Backup file: {backup_path}')
|
||||
print(f'Messages before backup: {before}')
|
||||
print(f'Messages after restore: {after}')
|
||||
print(f'Selected message restored: {selected_id == restored_id}')
|
||||
print(f'Restore time: {restore_seconds:.2f} s')
|
||||
if before != after or selected_id != restored_id:
|
||||
raise SystemExit('FAIL: restored data does not match source')
|
||||
finally:
|
||||
run(['docker', 'rm', '-f', RESTORE], check=False)
|
||||
|
||||
print('PASS: track 2 query-plan and backup/restore evidence')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Reference in New Issue
Block a user