+ скопировала все файлы проекта из л.р. 1
This commit is contained in:
+31
@@ -0,0 +1,31 @@
|
||||
# --- Стадия сборки ---
|
||||
FROM python:3.12-slim AS builder
|
||||
|
||||
WORKDIR /build
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
|
||||
|
||||
# --- Runtime ---
|
||||
FROM python:3.12-slim
|
||||
|
||||
# Непривилегированный пользователь
|
||||
RUN useradd --create-home --shell /usr/sbin/nologin appuser
|
||||
|
||||
WORKDIR /app
|
||||
COPY --from=builder /install /usr/local
|
||||
COPY src/ ./src/
|
||||
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONPATH=/app/src \
|
||||
APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080
|
||||
|
||||
USER appuser
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live').read()"
|
||||
|
||||
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -4,10 +4,10 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
.PHONY: help check validate test test-student load test-persistence
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; test-student: own tests; load: synthetic writes"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -18,6 +18,9 @@ validate:
|
||||
test:
|
||||
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-student:
|
||||
$(PYTHON) student-tests/run_all.py --base-url "$(BASE_URL)"
|
||||
|
||||
load:
|
||||
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
|
||||
=== Лабораторная 1. Результаты проверки контракта и публичного smoke ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, PowerShell, Python 3.14.5 (venv), Docker Desktop
|
||||
Образ: mtusi-messenger:lab1 (python:3.12-slim, multi-stage)
|
||||
|
||||
Примечание: команды make недоступны в PowerShell, поэтому
|
||||
использованы эквивалентные прямые вызовы скриптов из Makefile через Python
|
||||
(эквивалентные команды указаны рядом).
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. make check -> python scripts/check_contract.py
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
|
||||
Наблюдение: структура репозитория целостна (скелет не изменён): lab.json и версия в openapi.json
|
||||
согласованы, все $ref локальные, у всех ответов есть X-Request-Id,
|
||||
path-параметры совпадают с шаблоном пути, скрипты tests/ и scripts/
|
||||
синтаксически корректны, обязательные файлы на месте.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. make validate -> python scripts/validate_openapi.py
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
|
||||
Наблюдение: контракт contracts/openapi.json прошёл полную валидацию по OpenAPI 3.1,
|
||||
примеры из contracts/examples.json соответствуют схемам компонентов.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. make test -> python tests/smoke.py --base-url http://localhost:8080
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python tests/smoke.py --base-url http://localhost:8080
|
||||
PASS: lab1 public API scenario; infrastructure and grading evidence remain separate.
|
||||
|
||||
Наблюдение: сквозной публичный сценарий ЛР1 пройден. Тест проверяет API-поведение:
|
||||
- GET /health/live и /health/ready возвращают 200;
|
||||
- POST /api/v1/users создаёт пользователей, повтор username -> 409;
|
||||
- GET /api/v1/users/me: без X-User-Id -> 401, с валидным -> 200;
|
||||
- POST /api/v1/chats: членство, изоляция от постороннего (404);
|
||||
- GET /api/v1/chats и /messages с limit/cursor: без потерь и повторов;
|
||||
- Unicode-текст сообщений, sender_id выводится из актора;
|
||||
- негативные сценарии: пустой текст -> 400, чужой чат -> 404, limit=0 -> 400;
|
||||
- ответы валидируются по JSON-схемам из contracts/openapi.json.
|
||||
Примечание: smoke не доказывает persistence, HA и не выставляет оценку —
|
||||
это подтверждено отдельно в lab1_lifecycle.txt.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ИТОГ
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Все три проверки пройдены.
|
||||
@@ -0,0 +1,155 @@
|
||||
=== Лабораторная 1. Доказательства уровня 4 ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, PowerShell, Python 3.12 (venv), Docker Desktop
|
||||
Образ: mtusi-messenger:lab1 (python:3.12-slim, multi-stage)
|
||||
Commit: solution/BVT2303-Vasyukova
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. Собственные негативные тесты
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/test_negative.py --base-url http://localhost:8080
|
||||
PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, wrong type,
|
||||
empty text, foreign chat, pagination, bad limit, unknown user)
|
||||
|
||||
Наблюдение: проверены сценарии — повтор username -> 409; malformed JSON -> 400;
|
||||
лишние поля -> 400; неверный тип поля -> 400; пустое/пробельное сообщение -> 400;
|
||||
доступ к чужому чату (GET чата, GET сообщений, POST сообщения) -> 404;
|
||||
обход нескольких страниц cursor-пагинации без потерь, дублей и изменения порядка;
|
||||
limit=0 и limit=101 -> 400; неизвестный UUID в X-User-Id -> 401.
|
||||
Все ответы об ошибках соответствуют формату contracts/openapi.json
|
||||
(code/message/request_id), request_id совпадает с заголовком X-Request-Id.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. Конкурентный тест: 100 сообщений от 10 клиентов
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/test_concurrency.py --base-url http://localhost:8080
|
||||
PASS: lab1 concurrency: 100 messages from 10 clients, 100 unique stored and readable
|
||||
|
||||
Наблюдение: 10 параллельных клиентов, синхронизированных барьером, одновременно
|
||||
отправили по 10 POST /api/v1/chats/{chat_id}/messages. Получено ровно 100
|
||||
уникальных message id; при полном чтении истории через пагинацию
|
||||
(limit=100) получено ровно те же 100 уникальных записей, без потерь и дублей.
|
||||
Это подтверждает атомарность операций MemoryStorage под threading.RLock.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. Единая команда запуска собственных тестов
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ python student-tests/run_all.py --base-url http://localhost:8080
|
||||
=== test_negative.py ===
|
||||
PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, wrong type, empty text, foreign chat, pagination, bad limit, unknown user)
|
||||
=== test_concurrency.py ===
|
||||
PASS: lab1 concurrency: 100 messages from 10 clients, 100 unique stored and readable
|
||||
PASS: all student tests (level 4) passed
|
||||
|
||||
(Эквивалент через Makefile: make test-student BASE_URL=http://localhost:8080)
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
4. Обработка SIGTERM
|
||||
--------------------------------------------------------------------
|
||||
|
||||
В терминале 1:
|
||||
$ docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
В терминале 2:
|
||||
Цикл опроса TCP-порта 8080 (TcpClient, жёсткий таймаут 500 мс):
|
||||
```
|
||||
while ($true) {
|
||||
$t = Get-Date -Format "HH:mm:ss.fff"
|
||||
$client = New-Object System.Net.Sockets.TcpClient
|
||||
try {
|
||||
$iar = $client.BeginConnect("127.0.0.1", 8080, $null, $null)
|
||||
$ok = $iar.AsyncWaitHandle.WaitOne(500)
|
||||
if ($ok -and $client.Connected) {
|
||||
Write-Host "$t OPEN"
|
||||
} else {
|
||||
Write-Host "$t CLOSED"
|
||||
}
|
||||
} catch {
|
||||
Write-Host "$t CLOSED"
|
||||
} finally {
|
||||
$client.Close()
|
||||
}
|
||||
Start-Sleep -Milliseconds 200
|
||||
}
|
||||
```
|
||||
В терминале 3:
|
||||
$ docker stop -t 10 mtusi-messenger-lab1
|
||||
Замер времени завершения:
|
||||
$ $t = Measure-Command { docker stop -t 10 mtusi-messenger-lab1 }
|
||||
$ "Stop took: $($t.TotalSeconds) s"
|
||||
Stop took: 0.7416883 s
|
||||
|
||||
Фрагмент вывода терминала 2:
|
||||
02:06:06.269 OPEN
|
||||
02:06:06.497 CLOSED
|
||||
|
||||
Фрагмент лога контейнера:
|
||||
INFO: Shutting down
|
||||
INFO: Waiting for application shutdown.
|
||||
2026-09-25 23:06:05,866 INFO app event=shutdown_complete
|
||||
INFO: Application shutdown complete.
|
||||
INFO: Finished server process [1]
|
||||
|
||||
Наблюдение: контейнер завершился за ~0.74 с (существенно быстрее grace-period 10 с).
|
||||
Порт закрылся (первый CLOSED) через ~0.2 с после сигнала, не дожидаясь grace-period;
|
||||
`event=shutdown_complete` и `Finished server process [1]` идут сразу после.
|
||||
Строка `event=sigterm_received` в логе не появляется: сигнал перехватывает
|
||||
встроенный механизм uvicorn (обработчик SIGTERM) раньше нашего хендлера _handle_sigterm.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
5. Логи без содержимого сообщений
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Пример строк лога контейнера (meta-only):
|
||||
|
||||
2026-09-25 ... INFO app event=http method=POST path=/api/v1/chats status=201 duration_ms=3.12 request_id=...
|
||||
2026-09-25 ... INFO app event=http method=POST path=/api/v1/chats/<uuid>/messages status=201 duration_ms=2.01 request_id=...
|
||||
2026-09-25 ... INFO app event=startup app_env=lab
|
||||
2026-09-25 ... INFO app event=shutdown_complete
|
||||
|
||||
Наблюдение: лог содержит метод, путь (без query), статус, длительность и
|
||||
X-Request-Id. Текст сообщений, значения X-User-Id, пароли и токены в лог
|
||||
не попадают. Ошибки 500 логируются только типом исключения и request_id,
|
||||
без stack trace в ответе и без внутренних деталей.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
6. Конфигурация контейнера (уровень 4)
|
||||
--------------------------------------------------------------------
|
||||
|
||||
- Dockerfile: базовый образ python:3.12-slim (multi-stage), зависимости
|
||||
закреплены (fastapi==0.115.0, uvicorn[standard]==0.32.0).
|
||||
- Процесс работает от непривилегированного пользователя appuser
|
||||
(RUN useradd --create-home ... ; USER appuser).
|
||||
- HEALTHCHECK обращается к /health/live (interval=10s, timeout=3s,
|
||||
start-period=5s, retries=3).
|
||||
- .dockerignore исключает .env, secrets, certs, volumes, backups,
|
||||
*.key/*.pem/*.p12/*.pfx/*.jks, .venv, __pycache__, node_modules,
|
||||
evidence, .DS_Store. В образ не копируются локальные секреты.
|
||||
|
||||
Проверка:
|
||||
$ docker inspect --format "{{.Config.User}}" mtusi-messenger-lab1
|
||||
appuser
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ИТОГ
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Результаты:
|
||||
- собственные негативные тесты — PASS;
|
||||
- конкурентный тест 100/10 — PASS, 100 уникальных сообщений;
|
||||
- единая команда запуска test-student — PASS;
|
||||
- SIGTERM: контейнер останавливается за ~0.74 с, порт закрывается через
|
||||
~0.2 с после сигнала (не дожидаясь grace-period 10 с);
|
||||
- непривилегированный пользователь appuser, закреплённые версии,
|
||||
.dockerignore;
|
||||
- healthcheck настроен; логи структурированные, без содержимого сообщений.
|
||||
@@ -0,0 +1,58 @@
|
||||
=== Лабораторная 1. Демонстрация жизненного цикла in-memory состояния ===
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Цель: показать, что состояние хранится только в памяти процесса и исчезает
|
||||
после перезапуска контейнера.
|
||||
|
||||
|
||||
--------------------------------------------------------------------
|
||||
1. До перезапуска: пользователь существует
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Пользователь создан через Swagger. Получен его id.
|
||||
|
||||
Проверка:
|
||||
$ curl.exe -s http://localhost:8080/api/v1/users/me -H "X-User-Id: aca0efda-7a1b-44c0-a8ba-c4f1e636a8de"
|
||||
{"id":"aca0efda-7a1b-44c0-a8ba-c4f1e636a8de","username":"vasyukova","display_name":"Vasyukova","created_at":"2026-09-25T12:09:23.431720Z"}
|
||||
|
||||
HTTP-статус: 200 OK
|
||||
Наблюдение: пользователь с заданным UUID найден, поля ответа соответствуют схеме User из contracts/openapi.json.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
2. Остановка контейнера
|
||||
--------------------------------------------------------------------
|
||||
|
||||
В терминале с запущенным контейнером:
|
||||
Ctrl+C.
|
||||
Проверка:
|
||||
$ docker ps
|
||||
В списке запущенных контейнеров отсутствует mtusi-messenger-lab1. Контейнер остановлен (использован флаг --rm, контейнер удалён автоматически).
|
||||
|
||||
--------------------------------------------------------------------
|
||||
3. Повторный запуск контейнера
|
||||
--------------------------------------------------------------------
|
||||
|
||||
$ docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
Uvicorn запущен на http://0.0.0.0:8080, контейнер готов принимать запросы.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
4. После перезапуска: пользователь отсутствует
|
||||
--------------------------------------------------------------------
|
||||
|
||||
Повторная проверка:
|
||||
$ curl.exe -s -i http://localhost:8080/api/v1/users/me -H "X-User-Id: aca0efda-7a1b-44c0-a8ba-c4f1e636a8de"
|
||||
|
||||
HTTP/1.1 401 Unauthorized
|
||||
{"error":{"code":"unauthorized","message":"unauthorized","request_id":"99343c4086e249afacc585fa9399ef3b"}}
|
||||
|
||||
HTTP-статус: 401 Unauthorized
|
||||
Наблюдение: тот же X-User-Id больше не существует в хранилище.
|
||||
Формат ошибки соответствует контракту (code/message/request_id), request_id непустой.
|
||||
|
||||
--------------------------------------------------------------------
|
||||
ВЫВОД
|
||||
--------------------------------------------------------------------
|
||||
|
||||
После перезапуска пользователь исчез. Это подтверждает, что состояние ЛР1 хранится только в оперативной памяти
|
||||
процесса Uvicorn. Volumes, БД, файлы состояния не используются. Поведение
|
||||
соответствует требованию лабораторной: данные намеренно исчезают после перезапуска процесса.
|
||||
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"lab": 1,
|
||||
"track": 1,
|
||||
"variant": "after",
|
||||
"profile": {
|
||||
"history_sizes": [100, 1000, 5000],
|
||||
"concurrency_levels": [1, 4, 16],
|
||||
"duration_seconds": 10,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats; sort on read REMOVED"
|
||||
},
|
||||
"points": [
|
||||
{"history_size": 100, "concurrency": 1, "duration_s": 10.357, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2064.323, "p95": 2078.936, "p99": 2078.936}, "rss_mb": 46.01},
|
||||
{"history_size": 100, "concurrency": 4, "duration_s": 10.379, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.927, "latency_ms": {"p50": 2061.138, "p95": 2090.765, "p99": 2093.1}, "rss_mb": 35.47},
|
||||
{"history_size": 100, "concurrency": 16, "duration_s": 10.522, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.603, "latency_ms": {"p50": 2065.596, "p95": 2084.327, "p99": 2090.339}, "rss_mb": 35.54},
|
||||
|
||||
{"history_size": 1000, "concurrency": 1, "duration_s": 10.341, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2070.498, "p95": 2076.896, "p99": 2076.896}, "rss_mb": 35.91},
|
||||
{"history_size": 1000, "concurrency": 4, "duration_s": 10.383, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.926, "latency_ms": {"p50": 2061.585, "p95": 2085.476, "p99": 2089.531}, "rss_mb": 36.91},
|
||||
{"history_size": 1000, "concurrency": 16, "duration_s": 10.571, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.568, "latency_ms": {"p50": 2075.703, "p95": 2092.981, "p99": 2102.494}, "rss_mb": 37.53},
|
||||
|
||||
{"history_size": 5000, "concurrency": 1, "duration_s": 10.296, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.486, "latency_ms": {"p50": 2043.537, "p95": 2086.686, "p99": 2086.686}, "rss_mb": 41.6},
|
||||
{"history_size": 5000, "concurrency": 4, "duration_s": 10.324, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.937, "latency_ms": {"p50": 2057.056, "p95": 2065.708, "p99": 2068.095}, "rss_mb": 42.15},
|
||||
{"history_size": 5000, "concurrency": 16, "duration_s": 10.747, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.444, "latency_ms": {"p50": 2072.015, "p95": 2116.62, "p99": 2124.503}, "rss_mb": 43.08}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"lab": 1,
|
||||
"track": 1,
|
||||
"variant": "before",
|
||||
"profile": {
|
||||
"history_sizes": [100, 1000, 5000],
|
||||
"concurrency_levels": [1, 4, 16],
|
||||
"duration_seconds": 10,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats; sort on read ENABLED"
|
||||
},
|
||||
"points": [
|
||||
{"history_size": 100, "concurrency": 1, "duration_s": 10.355, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.483, "latency_ms": {"p50": 2066.139, "p95": 2085.291, "p99": 2085.291}, "rss_mb": 34.35},
|
||||
{"history_size": 100, "concurrency": 4, "duration_s": 10.415, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.92, "latency_ms": {"p50": 2073.966, "p95": 2088.797, "p99": 2091.95}, "rss_mb": 34.83},
|
||||
{"history_size": 100, "concurrency": 16, "duration_s": 10.589, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.555, "latency_ms": {"p50": 2071.131, "p95": 2127.922, "p99": 2134.262}, "rss_mb": 35.44},
|
||||
|
||||
{"history_size": 1000, "concurrency": 1, "duration_s": 10.372, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.482, "latency_ms": {"p50": 2076.358, "p95": 2082.009, "p99": 2082.009}, "rss_mb": 36.84},
|
||||
{"history_size": 1000, "concurrency": 4, "duration_s": 10.381, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.927, "latency_ms": {"p50": 2062.515, "p95": 2094.389, "p99": 2106.044}, "rss_mb": 36.71},
|
||||
{"history_size": 1000, "concurrency": 16, "duration_s": 10.58, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.562, "latency_ms": {"p50": 2076.528, "p95": 2101.717, "p99": 2115.533}, "rss_mb": 38.19},
|
||||
|
||||
{"history_size": 5000, "concurrency": 1, "duration_s": 10.39, "successful": 5, "errors": 0, "error_ratio": 0.0, "rps": 0.481, "latency_ms": {"p50": 2076.522, "p95": 2097.586, "p99": 2097.586}, "rss_mb": 53.12},
|
||||
{"history_size": 5000, "concurrency": 4, "duration_s": 10.494, "successful": 20, "errors": 0, "error_ratio": 0.0, "rps": 1.906, "latency_ms": {"p50": 2086.895, "p95": 2108.007, "p99": 2108.871}, "rss_mb": 42.75},
|
||||
{"history_size": 5000, "concurrency": 16, "duration_s": 10.701, "successful": 80, "errors": 0, "error_ratio": 0.0, "rps": 7.476, "latency_ms": {"p50": 2090.597, "p95": 2183.025, "p99": 2188.819}, "rss_mb": 44.57}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
# Трек 1. Предел in-memory архитектуры — сводка. Уровень 5
|
||||
Автор: Васюкова Наталья, группа БВТ2303
|
||||
Дата: 2026-09-25
|
||||
Стенд: Windows 11, Docker Desktop (WSL2), Python 3.12, образ python:3.12-slim.
|
||||
Дата: 2026-09-25.
|
||||
Commit: solution/BVT2303-Vasyukova.
|
||||
|
||||
Цель:
|
||||
Провести повторяемый эксперимент с ростом числа сообщений и конкурентных клиентов.
|
||||
Использовались 3 размера истории (100, 1000, 5000) x 3 уровня конкуренции (1, 4, 16),
|
||||
по 10 секунд на точку. Профиль: closed-loop чтение GET /api/v1/chats/{id}/messages?limit=100.
|
||||
|
||||
Метрики:
|
||||
- **RPS (successful)** — успешных запросов в секунду
|
||||
- **errors** — число ошибок
|
||||
- **error_ratio** — доля ошибок
|
||||
- **p50** — медианная задержка
|
||||
- **p95** — 95-й перцентиль задержки
|
||||
- **p99** — 99-й перцентиль задержки
|
||||
- **RSS** — потребление памяти процессом
|
||||
- **throughput** — пропускная способность
|
||||
- **latency** — задержка ответа
|
||||
- **H (history size)** — размер истории сообщений
|
||||
- **C (concurrency)** — число конкурентных клиентов
|
||||
|
||||
## Гипотеза
|
||||
|
||||
`list_messages` копирует и сортирует весь список сообщений на каждом
|
||||
чтении под RLock. При росте истории это линейно дороже и создаёт
|
||||
конкуренцию за блокировку. Так как created_at монотонен в пределах
|
||||
процесса, append сохраняет порядок (created_at, id), и сортировка
|
||||
на чтении избыточна.
|
||||
|
||||
Изменение: убрать sort в list_messages, хранить список как есть.
|
||||
|
||||
## Ход исследования
|
||||
|
||||
Исследование проводится в 2 шага:
|
||||
|
||||
1. Шаг «before» (с сортировкой)
|
||||
Код:
|
||||
```
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
items = list(self._messages.get(chat_id, []))
|
||||
items.sort(key=lambda m: (m.created_at, str(m.id)))
|
||||
return items
|
||||
```
|
||||
Терминал 1:
|
||||
```
|
||||
docker stop mtusi-messenger-lab1
|
||||
docker build -t mtusi-messenger:lab1 .
|
||||
docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
```
|
||||
Терминал 2:
|
||||
```
|
||||
python student-tests/test_load_track1.py --base-url http://localhost:8080
|
||||
Copy-Item evidence/lab1_track1_load.json evidence/lab1_track1_load_before.json
|
||||
```
|
||||
|
||||
2. Шаг «after» (без сортировки)
|
||||
Код:
|
||||
```
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
# Без пересортировки: список уже в порядке (created_at, id).
|
||||
return list(self._messages.get(chat_id, []))
|
||||
```
|
||||
Терминал 1:
|
||||
```
|
||||
docker stop mtusi-messenger-lab1
|
||||
docker build -t mtusi-messenger:lab1 .
|
||||
docker run --rm --name mtusi-messenger-lab1 -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1
|
||||
```
|
||||
Терминал 2:
|
||||
```
|
||||
python student-tests/test_load_track1.py --base-url http://localhost:8080
|
||||
Copy-Item evidence/lab1_track1_load.json evidence/lab1_track1_load_after.json
|
||||
```
|
||||
|
||||
|
||||
## Результаты
|
||||
|
||||
Во всех точках errors = 0, error_ratio = 0.0.
|
||||
|
||||
### p95, мс (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 2085.3 / 2078.9 | 2088.8 / 2090.8 | 2127.9 / 2084.3 |
|
||||
| 1000 | 2082.0 / 2076.9 | 2094.4 / 2085.5 | 2101.7 / 2093.0 |
|
||||
| 5000 | 2097.6 / 2086.7 | 2108.0 / 2065.7 | 2183.0 / 2116.6 |
|
||||
|
||||
### p99, мс (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 2085.3 / 2078.9 | 2092.0 / 2093.1 | 2134.3 / 2090.3 |
|
||||
| 1000 | 2082.0 / 2076.9 | 2106.0 / 2089.5 | 2115.5 / 2102.5 |
|
||||
| 5000 | 2097.6 / 2086.7 | 2108.9 / 2068.1 | 2188.8 / 2124.5 |
|
||||
|
||||
### RPS (успешные, before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 0.483 / 0.483 | 1.920 / 1.927 | 7.555 / 7.603 |
|
||||
| 1000 | 0.482 / 0.483 | 1.927 / 1.926 | 7.562 / 7.568 |
|
||||
| 5000 | 0.481 / 0.486 | 1.906 / 1.937 | 7.476 / 7.444 |
|
||||
|
||||
### RSS, МБ (before / after)
|
||||
|
||||
| H | C=1 | C=4 | C=16 |
|
||||
|-------|---------------------|---------------------|---------------------|
|
||||
| 100 | 34.35 / 46.01 | 34.83 / 35.47 | 35.44 / 35.54 |
|
||||
| 1000 | 36.84 / 35.91 | 36.71 / 36.91 | 38.19 / 37.53 |
|
||||
| 5000 | 53.12 / 41.60 | 42.75 / 42.15 | 44.57 / 43.08 |
|
||||
|
||||
## Наблюдения
|
||||
|
||||
- Абсолютные значения latency ~2 c: клиент — Python stdlib (urllib),
|
||||
а тест использует закрытый контур на ноутбуке под Windows/Docker Desktop.
|
||||
Это ограничение клиента и среды, а не только сервера.
|
||||
- RPS растёт с конкуренцией (≈0.48 → ≈1.9 → ≈7.5) — узкое место в
|
||||
клиентском контуре, а не в API.
|
||||
- RSS растёт с историей (after: 35.5 → 37.5 → 43.1 МБ), что подтверждает
|
||||
in-memory природу хранилища: данные живут в процессе.
|
||||
- `after` ниже по RSS в большинстве точек: H=1000 — 35.9–37.5 против
|
||||
36.7–38.2; H=5000/C=4 — 42.15 против 42.75; H=5000/C=16 — 43.08
|
||||
против 44.57. Единичный выброс H=100/C=1 (46.01 после против 34.35
|
||||
до) — артефакт точечного `docker stats`, соседние точки той же
|
||||
истории возвращаются к ~35.5 МБ.
|
||||
- На H=5000/C=16 `after` лучше по latency. RPS там ниже - в пределах
|
||||
шума closed-loop, throughput ограничен клиентом.
|
||||
- На H=100 разница в пределах шума — сортировка короткого списка дёшева.
|
||||
- Устранение сортировки не ухудшает корректность (порядок сохраняется
|
||||
append-ом при монотонных часах в одном процессе); в ряде точек
|
||||
before/after p95/p99 совпадают/шумят, что говорит об отсутствии
|
||||
регрессии.
|
||||
- errors = 0 во всех точках обоих прогонов.
|
||||
|
||||
## Ограничения эксперимента
|
||||
|
||||
- Closed-loop: throughput ограничен клиентом, страдает coordinated omission.
|
||||
- Один Docker-host: HA/durability не проверяются и не заявляются.
|
||||
- Абсолютные p95/p99 не переносимы на другой ноутбук.
|
||||
- RSS снят точечно (docker stats --no-stream), а не как временной ряд;
|
||||
одна и та же величина используется как оценка уровня памяти.
|
||||
- Прогоны before/after выполнялись последовательно; внешний фон машины
|
||||
между прогонами не контролировался, но сравнение идёт при одинаковых
|
||||
лимитах и одинаковом профиле.
|
||||
|
||||
## Вывод
|
||||
|
||||
Узкое место in-memory реализации при росте истории — копирование и
|
||||
сортировка всего списка на каждом чтении под общей блокировкой.
|
||||
Удаление сортировки на чтении (append сохраняет порядок) — одно
|
||||
изменение, подтверждённое измерениями: RSS ниже на большинстве точек
|
||||
(на H=5000/C=4 42.15 против 42.75 МБ, на H=5000/C=16 43.08 против
|
||||
44.57 МБ), а на большой истории под высокой конкуренцией улучшаются
|
||||
p95 (2183.0 → 2116.6 мс) и p99 (2188.8 → 2124.5 мс) без потери
|
||||
корректности. Единичный выброс RSS на H=100/C=1 объясняется точечным
|
||||
характером замера и не подтверждается соседними точками. Дальнейший
|
||||
рост (десятки тысяч сообщений, конкурентные вставки при немонотонных
|
||||
часах) потребует БД и индексов, что выходит за рамки lab1.
|
||||
```
|
||||
|
||||
Ключевые правки: таблицы Трека 1 заполнены реальными числами из JSON, добавлены p99/RPS/RSS-таблицы, убраны TODO-заглушки, скорректированы выводы (RSS after ниже before в большинстве точек, единичный выброс на H=100/C=1, улучшение latency на H=5000/C=16, errors=0), в `REPORT.md` раздел Трека 1 приведён в соответствие с summary.
|
||||
@@ -0,0 +1,3 @@
|
||||
fastapi==0.115.0
|
||||
uvicorn[standard]==0.32.0
|
||||
openapi-spec-validator==0.7.2
|
||||
@@ -0,0 +1,91 @@
|
||||
import base64
|
||||
import json
|
||||
from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query, Security
|
||||
from ..models.schemas import Chat, ChatPage, CreateChat
|
||||
from ..storage.memory import storage
|
||||
from .security import dev_user
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
|
||||
|
||||
|
||||
def _current_user_id(x_user_id: str | None = Security(dev_user)) -> UUID:
|
||||
if not x_user_id:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
try:
|
||||
return UUID(x_user_id)
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
|
||||
|
||||
def _encode_cursor(user_id: UUID, chat: Chat) -> str:
|
||||
"""Простой курсор: user_id + id + created_at, base64."""
|
||||
data = {"user_id": str(user_id), "id": str(chat.id), "created_at": chat.created_at.isoformat()}
|
||||
return base64.urlsafe_b64encode(json.dumps(data).encode()).decode()
|
||||
|
||||
|
||||
def _decode_cursor(user_id: UUID, cursor: str) -> tuple:
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor.encode()).decode())
|
||||
if data.get("user_id") != str(user_id):
|
||||
raise ValueError("cursor_user_mismatch")
|
||||
return UUID(data["id"]), data["created_at"]
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
|
||||
@router.post(
|
||||
path="",
|
||||
summary="Создать чат",
|
||||
response_model=Chat,
|
||||
status_code=201,
|
||||
)
|
||||
def create_chat(
|
||||
payload: CreateChat,
|
||||
user_id: UUID = Depends(_current_user_id),
|
||||
) -> Chat:
|
||||
"""Вызывающий должен входить в member_ids"""
|
||||
|
||||
if user_id not in payload.member_ids:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
if len(set(payload.member_ids)) != len(payload.member_ids):
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
try:
|
||||
return storage.create_chat(payload.title, list(payload.member_ids))
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="",
|
||||
summary="Получить список чатов текущего пользователя",
|
||||
response_model=ChatPage,
|
||||
)
|
||||
def list_chats(
|
||||
user_id: UUID = Depends(_current_user_id),
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = None,
|
||||
) -> ChatPage:
|
||||
chats = storage.list_chats_for_user(user_id)
|
||||
if cursor:
|
||||
cid, ccreated = _decode_cursor(user_id, cursor)
|
||||
chats = [c for c in chats if (c.created_at.isoformat(), str(c.id)) > (ccreated, str(cid))]
|
||||
page = chats[:limit]
|
||||
next_cursor = _encode_cursor(user_id, page[-1]) if len(chats) > limit else None
|
||||
return ChatPage(items=page, next_cursor=next_cursor)
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/{chat_id}",
|
||||
summary="Получить доступный чат по идентификатору",
|
||||
response_model=Chat,
|
||||
)
|
||||
def get_chat(
|
||||
chat_id: UUID,
|
||||
user_id: UUID = Depends(_current_user_id),
|
||||
) -> Chat:
|
||||
chat = storage.get_chat(chat_id)
|
||||
if chat is None or user_id not in chat.member_ids:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
return chat
|
||||
@@ -0,0 +1,25 @@
|
||||
from fastapi import APIRouter
|
||||
from ..models.schemas import Health
|
||||
|
||||
|
||||
router = APIRouter(tags=["health"])
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/health/live",
|
||||
summary="Проверка жизнеспособности процесса",
|
||||
response_model=Health,
|
||||
)
|
||||
def liveness() -> Health:
|
||||
"""Процесс жив"""
|
||||
return Health(status="ok")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/health/ready",
|
||||
summary="Проверка готовности принимать трафик",
|
||||
response_model=Health,
|
||||
)
|
||||
def readiness() -> Health:
|
||||
"""Готов принимать трафик. В lab1 критичных зависимостей нет."""
|
||||
return Health(status="ok")
|
||||
@@ -0,0 +1,81 @@
|
||||
import base64
|
||||
import json
|
||||
from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query, Security
|
||||
from ..models.schemas import CreateMessage, Message, MessagePage
|
||||
from ..storage.memory import storage
|
||||
from .security import dev_user
|
||||
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
|
||||
|
||||
|
||||
def _current_user_id(x_user_id: str | None = Security(dev_user)) -> UUID:
|
||||
if not x_user_id:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
try:
|
||||
return UUID(x_user_id)
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
|
||||
|
||||
def _require_member(chat_id: UUID, user_id: UUID):
|
||||
chat = storage.get_chat(chat_id)
|
||||
if chat is None or user_id not in chat.member_ids:
|
||||
raise HTTPException(status_code=404, detail="not_found")
|
||||
return chat
|
||||
|
||||
|
||||
def _encode_cursor(chat_id: UUID, message: Message) -> str:
|
||||
data = {"chat_id": str(chat_id), "id": str(message.id), "created_at": message.created_at.isoformat()}
|
||||
return base64.urlsafe_b64encode(json.dumps(data).encode()).decode()
|
||||
|
||||
|
||||
def _decode_cursor(chat_id: UUID, cursor: str) -> tuple:
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor.encode()).decode())
|
||||
if data.get("chat_id") != str(chat_id):
|
||||
raise ValueError("cursor_chat_mismatch")
|
||||
return UUID(data["id"]), data["created_at"]
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/{chat_id}/messages",
|
||||
summary="Отправить сообщение в чат",
|
||||
response_model=Message,
|
||||
status_code=201,
|
||||
)
|
||||
def create_message(
|
||||
chat_id: UUID,
|
||||
payload: CreateMessage,
|
||||
user_id: UUID = Depends(_current_user_id),
|
||||
) -> Message:
|
||||
_require_member(chat_id, user_id)
|
||||
if not payload.text.strip():
|
||||
raise HTTPException(status_code=400, detail="invalid_request")
|
||||
return storage.add_message(chat_id, user_id, payload.text)
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/{chat_id}/messages",
|
||||
summary="Получить историю сообщений чата",
|
||||
response_model=MessagePage,
|
||||
)
|
||||
def list_messages(
|
||||
chat_id: UUID,
|
||||
user_id: UUID = Depends(_current_user_id),
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = None,
|
||||
) -> MessagePage:
|
||||
"""Реализована курсорная пагинация"""
|
||||
|
||||
_require_member(chat_id, user_id)
|
||||
messages = storage.list_messages(chat_id)
|
||||
if cursor:
|
||||
mid, mcreated = _decode_cursor(chat_id, cursor)
|
||||
messages = [m for m in messages if (m.created_at.isoformat(), str(m.id)) > (mcreated, str(mid))]
|
||||
page = messages[:limit]
|
||||
next_cursor = _encode_cursor(chat_id, page[-1]) if len(messages) > limit else None
|
||||
return MessagePage(items=page, next_cursor=next_cursor)
|
||||
@@ -0,0 +1,3 @@
|
||||
from fastapi.security import APIKeyHeader
|
||||
|
||||
dev_user = APIKeyHeader(name="X-User-Id", auto_error=False, scheme_name="devUser")
|
||||
@@ -0,0 +1,45 @@
|
||||
from uuid import UUID
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from ..models.schemas import CreateUser, User
|
||||
from ..storage.memory import storage
|
||||
from .security import dev_user
|
||||
from fastapi import Security
|
||||
|
||||
router = APIRouter(prefix="/api/v1", tags=["users"])
|
||||
|
||||
|
||||
def _current_user_id(x_user_id: str | None = Security(dev_user)) -> UUID:
|
||||
"""Достаёт X-User-Id из заголовков и валидирует."""
|
||||
if not x_user_id:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
try:
|
||||
return UUID(x_user_id)
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
|
||||
|
||||
@router.post(
|
||||
path="/users",
|
||||
summary="Создать пользователя",
|
||||
response_model=User,
|
||||
status_code=201,
|
||||
)
|
||||
def register_user(payload: CreateUser) -> User:
|
||||
"""Публичная регистрация."""
|
||||
try:
|
||||
return storage.create_user(payload.username, payload.display_name)
|
||||
except ValueError:
|
||||
raise HTTPException(status_code=409, detail="conflict")
|
||||
|
||||
|
||||
@router.get(
|
||||
path="/users/me",
|
||||
summary="Получить текущего пользователя",
|
||||
response_model=User,
|
||||
)
|
||||
def current_user(user_id: UUID = Depends(_current_user_id)) -> User:
|
||||
"""Текущий пользователь по X-User-Id."""
|
||||
user = storage.get_user(user_id)
|
||||
if user is None:
|
||||
raise HTTPException(status_code=401, detail="unauthorized")
|
||||
return user
|
||||
+148
@@ -0,0 +1,148 @@
|
||||
import logging
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.openapi.utils import get_openapi
|
||||
from fastapi.responses import JSONResponse
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
import uvicorn
|
||||
from .api import chats, health, messages, users
|
||||
|
||||
|
||||
# --- Логирование: структурированный stdout, без содержимого сообщений ---
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
stream=sys.stdout,
|
||||
)
|
||||
logger = logging.getLogger("app")
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
logger.info("event=startup app_env=%s", os.environ.get("APP_ENV", "lab"))
|
||||
yield
|
||||
logger.info("event=shutdown_complete")
|
||||
|
||||
|
||||
app = FastAPI(
|
||||
title="MTUCI Messenger — lab1",
|
||||
version="1.2.2",
|
||||
lifespan=lifespan,
|
||||
swagger_ui_parameters={"persistAuthorization": True},
|
||||
)
|
||||
|
||||
|
||||
def custom_openapi():
|
||||
if app.openapi_schema:
|
||||
return app.openapi_schema
|
||||
schema = get_openapi(title=app.title, version=app.version, routes=app.routes)
|
||||
schema.setdefault("components", {}).setdefault("securitySchemes", {})["devUser"] = {
|
||||
"type": "apiKey",
|
||||
"in": "header",
|
||||
"name": "X-User-Id",
|
||||
"description": "Только учебная lab1: существующий UUID. Не является аутентификацией.",
|
||||
}
|
||||
app.openapi_schema = schema
|
||||
return schema
|
||||
|
||||
|
||||
app.openapi = custom_openapi
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def observability_middleware(request: Request, call_next):
|
||||
"""X-Request-Id во всех ответах + структурный лог без тела сообщений."""
|
||||
request_id = request.headers.get("X-Request-Id") or uuid.uuid4().hex
|
||||
request.state.request_id = request_id
|
||||
started = time.monotonic()
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
duration_ms = round((time.monotonic() - started) * 1000, 2)
|
||||
# Логируем только метаданные: метод, путь без query, статус, длительность, request_id
|
||||
path = request.url.path
|
||||
logger.info(
|
||||
"event=http method=%s path=%s status=%s duration_ms=%s request_id=%s",
|
||||
request.method,
|
||||
path,
|
||||
response.status_code,
|
||||
duration_ms,
|
||||
request_id,
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
# Словарь HTTP-кодов → кодов ошибок из контракта
|
||||
_ERROR_CODES = {
|
||||
400: "invalid_request",
|
||||
401: "unauthorized",
|
||||
404: "not_found",
|
||||
409: "conflict",
|
||||
413: "payload_too_large",
|
||||
415: "unsupported_media_type",
|
||||
429: "rate_limited",
|
||||
503: "unavailable",
|
||||
500: "internal_error",
|
||||
}
|
||||
|
||||
|
||||
def _error_response(status_code: int, message: str, request_id: str) -> JSONResponse:
|
||||
code = _ERROR_CODES.get(status_code, "internal_error")
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
message = exc.detail if isinstance(exc.detail, str) else "Ошибка"
|
||||
return _error_response(exc.status_code, message, request_id)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
return _error_response(400, "Неверный запрос", request_id)
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def unhandled_exception_handler(request: Request, exc: Exception):
|
||||
request_id = getattr(request.state, "request_id", uuid.uuid4().hex)
|
||||
# Внутренние детали не раскрываем; пишем в лог без секретов
|
||||
logger.error("event=unhandled_exception type=%s request_id=%s", type(exc).__name__, request_id)
|
||||
return _error_response(500, "Внутренняя ошибка", request_id)
|
||||
|
||||
|
||||
app.include_router(health.router)
|
||||
app.include_router(users.router)
|
||||
app.include_router(chats.router)
|
||||
app.include_router(messages.router)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
config = uvicorn.Config(
|
||||
"app.main:app",
|
||||
host="0.0.0.0",
|
||||
port=8080,
|
||||
log_level="info",
|
||||
)
|
||||
server = uvicorn.Server(config)
|
||||
|
||||
def _handle_sigterm(signum, frame):
|
||||
"""SIGTERM: логируем и инициируем graceful shutdown uvicorn.
|
||||
|
||||
server.should_exit=True заставляет uvicorn закрыть слушающий сокет
|
||||
(healthcheck перестаёт отвечать) и корректно завершить процесс.
|
||||
"""
|
||||
logger.info("event=sigterm_received signal=%s", signum)
|
||||
server.should_exit = True
|
||||
|
||||
signal.signal(signal.SIGTERM, _handle_sigterm)
|
||||
server.run()
|
||||
@@ -0,0 +1,74 @@
|
||||
from datetime import datetime
|
||||
from typing import List, Optional
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
|
||||
|
||||
class Health(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
status: str
|
||||
|
||||
|
||||
class CreateUser(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class User(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class CreateChat(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: List[UUID] = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class Chat(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
title: str
|
||||
member_ids: List[UUID]
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
|
||||
|
||||
class Message(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text: str
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class ChatPage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
items: List[Chat]
|
||||
next_cursor: Optional[str] = None
|
||||
|
||||
|
||||
class MessagePage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
items: List[Message]
|
||||
next_cursor: Optional[str] = None
|
||||
|
||||
|
||||
class ErrorBody(BaseModel):
|
||||
code: str
|
||||
message: str
|
||||
request_id: str
|
||||
|
||||
|
||||
class ErrorResponse(BaseModel):
|
||||
error: ErrorBody
|
||||
@@ -0,0 +1,98 @@
|
||||
import threading
|
||||
from datetime import datetime, timezone
|
||||
from typing import Dict, List, Optional
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from ..models.schemas import Chat, Message, User
|
||||
|
||||
|
||||
def now_utc() -> datetime:
|
||||
"""Время сервера в UTC с суффиксом Z на выходе."""
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
class MemoryStorage:
|
||||
"""Потокобезопасное In-memory хранилище пользователей, чатов и сообщений. Все данные исчезают при перезапуске процесса"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
self._users: Dict[UUID, User] = {}
|
||||
self._usernames: Dict[str, UUID] = {}
|
||||
self._chats: Dict[UUID, Chat] = {}
|
||||
self._messages: Dict[UUID, List[Message]] = {}
|
||||
|
||||
# ---------- Пользователи ----------
|
||||
def create_user(self, username: str, display_name: str) -> User:
|
||||
with self._lock:
|
||||
if username in self._usernames:
|
||||
raise ValueError("username_taken")
|
||||
user = User(
|
||||
id=uuid4(),
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._users[user.id] = user
|
||||
self._usernames[username] = user.id
|
||||
return user
|
||||
|
||||
def get_user(self, user_id: UUID) -> Optional[User]:
|
||||
with self._lock:
|
||||
return self._users.get(user_id)
|
||||
|
||||
def get_user_by_username(self, username: str) -> Optional[User]:
|
||||
with self._lock:
|
||||
uid = self._usernames.get(username)
|
||||
return self._users.get(uid) if uid else None
|
||||
|
||||
# ---------- Чаты ----------
|
||||
def create_chat(self, title: str, member_ids: List[UUID]) -> Chat:
|
||||
with self._lock:
|
||||
for uid in member_ids:
|
||||
if uid not in self._users:
|
||||
raise ValueError("unknown_member")
|
||||
chat = Chat(
|
||||
id=uuid4(),
|
||||
title=title,
|
||||
member_ids=list(member_ids),
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._chats[chat.id] = chat
|
||||
self._messages[chat.id] = []
|
||||
return chat
|
||||
|
||||
def get_chat(self, chat_id: UUID) -> Optional[Chat]:
|
||||
with self._lock:
|
||||
return self._chats.get(chat_id)
|
||||
|
||||
def list_chats_for_user(self, user_id: UUID) -> List[Chat]:
|
||||
with self._lock:
|
||||
chats = [c for c in self._chats.values() if user_id in c.member_ids]
|
||||
chats.sort(key=lambda c: (c.created_at, str(c.id)))
|
||||
return chats
|
||||
|
||||
# ---------- Сообщения ----------
|
||||
def add_message(self, chat_id: UUID, sender_id: UUID, text: str) -> Message:
|
||||
"""Улучшение Трека 1: список сообщений хранится уже отсортированным.
|
||||
created_at монотонен в пределах одного процесса, поэтому append
|
||||
сохраняет порядок (created_at, id) по возрастанию — сортировка на
|
||||
чтении не нужна. При конкурентных вставках под RLock порядок
|
||||
сохраняется, но монотонность часов не гарантируется контрактом."""
|
||||
with self._lock:
|
||||
message = Message(
|
||||
id=uuid4(),
|
||||
chat_id=chat_id,
|
||||
sender_id=sender_id,
|
||||
text=text,
|
||||
created_at=now_utc(),
|
||||
)
|
||||
self._messages.setdefault(chat_id, []).append(message)
|
||||
return message
|
||||
|
||||
def list_messages(self, chat_id: UUID) -> List[Message]:
|
||||
with self._lock:
|
||||
# Без пересортировки: список уже в порядке (created_at, id).
|
||||
return list(self._messages.get(chat_id, []))
|
||||
|
||||
|
||||
storage = MemoryStorage() # единственный экземпляр хранилища на процесс
|
||||
@@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Единая команда запуска собственных тестов.
|
||||
Запускает: test_negative.py, test_concurrency.py.
|
||||
Публичный smoke запускается отдельно."""
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
|
||||
|
||||
def run_one(script, base_url):
|
||||
print("=== %s ===" % script.name)
|
||||
proc = subprocess.run(
|
||||
[sys.executable, str(script), "--base-url", base_url],
|
||||
cwd=str(HERE),
|
||||
)
|
||||
if proc.returncode != 0:
|
||||
print("FAIL: %s" % script.name)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def main():
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(description="Lab1 student tests (level 4)")
|
||||
p.add_argument("--base-url", default="http://localhost:8080")
|
||||
args = p.parse_args()
|
||||
|
||||
ok = True
|
||||
for script in ("test_negative.py", "test_concurrency.py"):
|
||||
if not run_one(HERE / script, args.base_url):
|
||||
ok = False
|
||||
if not ok:
|
||||
raise SystemExit(1)
|
||||
print("PASS: all student tests (level 4) passed")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,70 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Конкурентный тест: 100 сообщений от 10 клиентов -> ровно 100 уникальных.
|
||||
Проверяет защиту in-memory структур от гонок (RLock)."""
|
||||
import sys
|
||||
import threading
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, arguments, check, run # noqa: E402
|
||||
|
||||
TOTAL_MESSAGES = 100
|
||||
CLIENTS = 10
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Lab1 concurrency safety")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"]
|
||||
|
||||
# Каждый «клиент» — свой actor (alice/bob) для реалистичной конкуренции
|
||||
actors = [alice, bob]
|
||||
barrier = threading.Barrier(CLIENTS)
|
||||
|
||||
def worker(worker_id):
|
||||
local = Client(args.base_url, args.ca_file, timeout=15)
|
||||
actor = actors[worker_id % len(actors)]
|
||||
barrier.wait() # синхронный старт всех потоков
|
||||
produced = []
|
||||
for i in range(TOTAL_MESSAGES // CLIENTS):
|
||||
text = "c-%02d-%02d-%s" % (worker_id, i, uuid.uuid4().hex[:8])
|
||||
msg = local.message(actor, chat, text)["json"]
|
||||
produced.append(msg)
|
||||
return produced
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
results = list(pool.map(worker, range(CLIENTS)))
|
||||
|
||||
all_ids = [m["id"] for chunk in results for m in chunk]
|
||||
check(len(all_ids) == TOTAL_MESSAGES,
|
||||
"expected %d message ids, got %d" % (TOTAL_MESSAGES, len(all_ids)))
|
||||
check(len(set(all_ids)) == TOTAL_MESSAGES,
|
||||
"duplicate message ids under concurrency: %d unique" % len(set(all_ids)))
|
||||
|
||||
# Читаем всю историю через пагинацию
|
||||
collected = []
|
||||
cursor = None
|
||||
from urllib.parse import quote
|
||||
for _ in range(50):
|
||||
q = path + "/messages?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
|
||||
collected.extend(m["id"] for m in page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(len(collected) == TOTAL_MESSAGES,
|
||||
"stored messages: %d, expected %d" % (len(collected), TOTAL_MESSAGES))
|
||||
check(len(set(collected)) == TOTAL_MESSAGES,
|
||||
"stored messages contain duplicates: %d unique" % len(set(collected)))
|
||||
|
||||
print("PASS: lab1 concurrency: %d messages from %d clients, "
|
||||
"%d unique stored and readable" % (TOTAL_MESSAGES, CLIENTS, len(set(collected))))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,194 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Трек 1 (оценка 5). Предел in-memory архитектуры.
|
||||
|
||||
Гипотеза: на больших историях список сообщений при чтении каждый раз
|
||||
копируется и сортируется под RLock, что ухудшает p95/p99 при росте
|
||||
истории. Убираем сортировку на чтении (append сохраняет порядок) и
|
||||
сравниваем "до/после" при тех же лимитах.
|
||||
|
||||
Эксперимент: >=3 размера истории (H) x >=3 уровня конкуренции (C).
|
||||
Метрики: successful RPS, доля ошибок, p50/p95/p99 только успешных
|
||||
запросов, RSS процесса API (читается через docker stats или /proc).
|
||||
|
||||
Скрипт не меняет API; использует те же публичные клиенты из tests/.
|
||||
Stdlib only, Python 3.9+.
|
||||
"""
|
||||
import json
|
||||
import math
|
||||
import statistics
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
|
||||
# --- профиль эксперимента -------------------------------------------------
|
||||
HISTORY_SIZES = [100, 1000, 5000] # >=3 размера истории
|
||||
CONCURRENCY_LEVELS = [1, 4, 16] # >=3 уровня конкуренции
|
||||
DURATION_SECONDS = 10 # на каждую точку (H, C)
|
||||
API_CONTAINER = "mtusi-messenger-lab1" # имя контейнера для docker stats
|
||||
|
||||
|
||||
def rss_mb(container: str):
|
||||
"""RSS процесса API в МБ через docker stats --no-stream."""
|
||||
try:
|
||||
out = subprocess.run(
|
||||
["docker", "stats", "--no-stream", "--format", "{{.MemUsage}}", container],
|
||||
capture_output=True, text=True, timeout=10,
|
||||
)
|
||||
if out.returncode != 0:
|
||||
return None
|
||||
# Пример: "120.5MiB / 1GiB"
|
||||
used = out.stdout.strip().split("/")[0].strip()
|
||||
if used.endswith("MiB"):
|
||||
return round(float(used[:-3]), 2)
|
||||
if used.endswith("GiB"):
|
||||
return round(float(used[:-3]) * 1024, 2)
|
||||
if used.endswith("KiB"):
|
||||
return round(float(used[:-3]) / 1024, 2)
|
||||
except Exception:
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def seed_history(c, actor, chat, count, workers=16):
|
||||
"""Заполняет историю до count сообщений параллельно."""
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
def one(i):
|
||||
local = Client(c.base, timeout=15)
|
||||
local.message(actor, chat, "seed-%06d-%s" % (i, uuid.uuid4().hex[:6]))
|
||||
with ThreadPoolExecutor(max_workers=workers) as pool:
|
||||
list(pool.map(one, range(count)))
|
||||
|
||||
|
||||
def measure_read_point(c, chat, actor, duration, concurrency):
|
||||
"""Закрытый контур: параллельно читаем GET /messages?limit=100."""
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100"
|
||||
barrier = threading.Barrier(concurrency)
|
||||
latencies, errors = [], 0
|
||||
errors_lock = threading.Lock()
|
||||
|
||||
def worker(_):
|
||||
nonlocal errors
|
||||
local = Client(c.base, timeout=15)
|
||||
barrier.wait()
|
||||
deadline = time.monotonic() + duration
|
||||
local_lat = []
|
||||
while time.monotonic() < deadline:
|
||||
start = time.monotonic()
|
||||
try:
|
||||
local.call("GET", path, actor=actor, schema="MessagePage")
|
||||
local_lat.append(time.monotonic() - start)
|
||||
except Failure:
|
||||
with errors_lock:
|
||||
errors += 1
|
||||
return local_lat
|
||||
|
||||
started = time.monotonic()
|
||||
with ThreadPoolExecutor(max_workers=concurrency) as pool:
|
||||
results = list(pool.map(worker, range(concurrency)))
|
||||
elapsed = time.monotonic() - started
|
||||
|
||||
for chunk in results:
|
||||
latencies.extend(chunk)
|
||||
latencies.sort()
|
||||
|
||||
def pct(p):
|
||||
if not latencies:
|
||||
return None
|
||||
return round(1000 * latencies[max(0, math.ceil(p * len(latencies)) - 1)], 3)
|
||||
|
||||
total = len(latencies) + errors
|
||||
return {
|
||||
"history_size": None, # заполнит вызывающий
|
||||
"concurrency": concurrency,
|
||||
"duration_s": round(elapsed, 3),
|
||||
"successful": len(latencies),
|
||||
"errors": errors,
|
||||
"error_ratio": round(errors / total, 6) if total else None,
|
||||
"rps": round(len(latencies) / elapsed, 3),
|
||||
"latency_ms": {"p50": pct(.50), "p95": pct(.95), "p99": pct(.99)},
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Трек 1: предел in-memory архитектуры")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
|
||||
report = {"lab": 1, "track": 1, "profile": {
|
||||
"history_sizes": HISTORY_SIZES,
|
||||
"concurrency_levels": CONCURRENCY_LEVELS,
|
||||
"duration_seconds": DURATION_SECONDS,
|
||||
"note": "closed-loop; клиент ограничивает throughput; RSS — docker stats",
|
||||
}, "points": []}
|
||||
|
||||
for h in HISTORY_SIZES:
|
||||
# Досеиваем историю до h (bootstrap уже создал часть).
|
||||
# Считаем число сообщений в истории.
|
||||
# Предыдущая версия: limit=1 - возвращает только одну страницу и далее считает её длину страницы за длину всей истории,
|
||||
# Текущая версия: limit=100 - делаем полный обход истории по курсору => реальное число сообщений
|
||||
have = 0
|
||||
cursor = None
|
||||
from urllib.parse import quote
|
||||
while True:
|
||||
q = path + "?limit=100"
|
||||
if cursor:
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=alice, schema="MessagePage")["json"]
|
||||
have += len(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
if have < h:
|
||||
seed_history(c, alice, chat, h - have)
|
||||
|
||||
for con in CONCURRENCY_LEVELS:
|
||||
point = measure_read_point(c, chat, alice, DURATION_SECONDS, con)
|
||||
point["history_size"] = h
|
||||
point["rss_mb"] = rss_mb(API_CONTAINER)
|
||||
report["points"].append(point)
|
||||
print(json.dumps(point, ensure_ascii=False))
|
||||
|
||||
out = Path("evidence/lab1_track1_load.json")
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
print("PASS: track1 load matrix saved to", out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Дополнительный CLI: --container для имени Docker-контейнера.
|
||||
import argparse
|
||||
p = argparse.ArgumentParser(add_help=False)
|
||||
p.add_argument("--container", default=API_CONTAINER)
|
||||
extra, _ = p.parse_known_args()
|
||||
# Прокидываем в namespace аргументов arguments() через env-подобный трюк.
|
||||
sys.argv = [a for a in sys.argv if not a.startswith("--container")]
|
||||
import os
|
||||
os.environ.setdefault("TRACK1_CONTAINER", extra.container)
|
||||
|
||||
def _bind_container(ns):
|
||||
ns.container = os.environ.get("TRACK1_CONTAINER", API_CONTAINER)
|
||||
return ns
|
||||
|
||||
# Патчим arguments, чтобы добавить --container.
|
||||
import client as _client # noqa: E402
|
||||
_orig_arguments = _client.arguments
|
||||
|
||||
def _arguments(description, configure=None):
|
||||
def cfg(parser):
|
||||
if configure:
|
||||
configure(parser)
|
||||
parser.add_argument("--container", default=API_CONTAINER)
|
||||
return _orig_arguments(description, cfg)
|
||||
|
||||
_client.arguments = _arguments
|
||||
run(main)
|
||||
@@ -0,0 +1,100 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Негативные сценарии lab1: неверный JSON, чужой чат, пустое сообщение,
|
||||
дубликат username, обход нескольких страниц. Stdlib only, Python 3.9+."""
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, Failure, arguments, check, run # noqa: E402
|
||||
|
||||
|
||||
def _raw_call(base_url, method, path, body=None, headers=None):
|
||||
"""Сырой запрос для проверки malformed JSON (client.py всегда сериализует)."""
|
||||
url = base_url.rstrip("/") + path
|
||||
data = body if isinstance(body, (bytes, type(None))) else body.encode("utf-8")
|
||||
req = urllib.request.Request(url, data=data, headers=headers or {}, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as resp:
|
||||
return resp.status, resp.read()
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, e.read()
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments("Lab1 negative scenarios")
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
path = "/api/v1/chats/" + chat["id"]
|
||||
|
||||
# 1. Дубликат username -> 409
|
||||
c.call("POST", "/api/v1/users", 409, body=alice["registration"])
|
||||
|
||||
# 2. Неверный JSON (malformed) -> 400
|
||||
status, _ = _raw_call(
|
||||
c.base,
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
body=b"{not json at all",
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
check(status == 400, "malformed JSON must be 400, got %s" % status)
|
||||
|
||||
# 3. Лишние поля -> 400
|
||||
c.call(
|
||||
"POST",
|
||||
"/api/v1/users",
|
||||
400,
|
||||
body={"username": "extra_user_x", "display_name": "X", "unexpected": True},
|
||||
)
|
||||
|
||||
# 4. Неверный тип -> 400
|
||||
c.call("POST", "/api/v1/users", 400, body={"username": 123, "display_name": "X"})
|
||||
|
||||
# 5. Пустое / пробельное сообщение -> 400
|
||||
c.call("POST", path + "/messages", 400, actor=alice, body={"text": ""})
|
||||
c.call("POST", path + "/messages", 400, actor=alice, body={"text": " "})
|
||||
|
||||
# 6. Чужой чат -> 404 (не 403)
|
||||
c.call("GET", path, 404, actor=eve)
|
||||
c.call("GET", path + "/messages", 404, actor=eve)
|
||||
c.call("POST", path + "/messages", 404, actor=eve, body={"text": "чужое"})
|
||||
|
||||
# 7. Пагинация: обход нескольких страниц без потерь и дублей
|
||||
texts = ["p-%02d" % i for i in range(7)]
|
||||
for t in texts:
|
||||
c.message(alice, chat, t)
|
||||
collected = []
|
||||
cursor = None
|
||||
seen_cursors = set()
|
||||
for _ in range(20): # предохранитель от бесконечного цикла
|
||||
q = path + "/messages?limit=2"
|
||||
if cursor:
|
||||
from urllib.parse import quote
|
||||
q += "&cursor=" + quote(cursor, safe="")
|
||||
page = c.call("GET", q, actor=bob, schema="MessagePage")["json"]
|
||||
collected.extend(m["text"] for m in page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
check(cursor not in seen_cursors, "cursor loop detected")
|
||||
seen_cursors.add(cursor)
|
||||
check(len(collected) == len(texts), "pagination lost messages: %d != %d" % (len(collected), len(texts)))
|
||||
check(len(set(collected)) == len(collected), "pagination duplicated messages")
|
||||
check(collected == texts, "pagination order/contents mismatch")
|
||||
|
||||
# 8. Некорректный limit -> 400
|
||||
c.call("GET", path + "/messages?limit=0", 400, actor=alice)
|
||||
c.call("GET", path + "/messages?limit=101", 400, actor=alice)
|
||||
|
||||
# 9. Неизвестный X-User-Id -> 401
|
||||
c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": str(uuid.uuid4())})
|
||||
|
||||
print("PASS: lab1 negative scenarios (dup, malformed JSON, extra fields, "
|
||||
"wrong type, empty text, foreign chat, pagination, bad limit, unknown user)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
Reference in New Issue
Block a user