diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..867d7a1f --- /dev/null +++ b/Dockerfile @@ -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"] \ No newline at end of file diff --git a/Makefile b/Makefile index 9ecb223e..0a7bc12a 100644 --- a/Makefile +++ b/Makefile @@ -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) diff --git a/evidence/lab1_checks.txt b/evidence/lab1_checks.txt new file mode 100644 index 00000000..16aa4118 --- /dev/null +++ b/evidence/lab1_checks.txt @@ -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. + +-------------------------------------------------------------------- +ИТОГ +-------------------------------------------------------------------- + +Все три проверки пройдены. diff --git a/evidence/lab1_level4.txt b/evidence/lab1_level4.txt new file mode 100644 index 00000000..abf349b4 --- /dev/null +++ b/evidence/lab1_level4.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//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 настроен; логи структурированные, без содержимого сообщений. \ No newline at end of file diff --git a/evidence/lab1_lifecycle.txt b/evidence/lab1_lifecycle.txt new file mode 100644 index 00000000..d08a19e5 --- /dev/null +++ b/evidence/lab1_lifecycle.txt @@ -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, БД, файлы состояния не используются. Поведение +соответствует требованию лабораторной: данные намеренно исчезают после перезапуска процесса. diff --git a/evidence/lab1_track1_load_after.json b/evidence/lab1_track1_load_after.json new file mode 100644 index 00000000..e83b9575 --- /dev/null +++ b/evidence/lab1_track1_load_after.json @@ -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} + ] +} \ No newline at end of file diff --git a/evidence/lab1_track1_load_before.json b/evidence/lab1_track1_load_before.json new file mode 100644 index 00000000..b7e823ce --- /dev/null +++ b/evidence/lab1_track1_load_before.json @@ -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} + ] +} \ No newline at end of file diff --git a/evidence/lab1_track1_summary.md b/evidence/lab1_track1_summary.md new file mode 100644 index 00000000..d0d20b2e --- /dev/null +++ b/evidence/lab1_track1_summary.md @@ -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. \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..e17eb12c --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +fastapi==0.115.0 +uvicorn[standard]==0.32.0 +openapi-spec-validator==0.7.2 \ No newline at end of file diff --git a/src/app/__init__.py b/src/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app/api/__init__.py b/src/app/api/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app/api/chats.py b/src/app/api/chats.py new file mode 100644 index 00000000..bdb123a4 --- /dev/null +++ b/src/app/api/chats.py @@ -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 \ No newline at end of file diff --git a/src/app/api/health.py b/src/app/api/health.py new file mode 100644 index 00000000..e407bee2 --- /dev/null +++ b/src/app/api/health.py @@ -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") \ No newline at end of file diff --git a/src/app/api/messages.py b/src/app/api/messages.py new file mode 100644 index 00000000..2e2b701f --- /dev/null +++ b/src/app/api/messages.py @@ -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) \ No newline at end of file diff --git a/src/app/api/security.py b/src/app/api/security.py new file mode 100644 index 00000000..c06469d7 --- /dev/null +++ b/src/app/api/security.py @@ -0,0 +1,3 @@ +from fastapi.security import APIKeyHeader + +dev_user = APIKeyHeader(name="X-User-Id", auto_error=False, scheme_name="devUser") \ No newline at end of file diff --git a/src/app/api/users.py b/src/app/api/users.py new file mode 100644 index 00000000..420e24a3 --- /dev/null +++ b/src/app/api/users.py @@ -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 \ No newline at end of file diff --git a/src/app/main.py b/src/app/main.py new file mode 100644 index 00000000..6ff4d9c6 --- /dev/null +++ b/src/app/main.py @@ -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() \ No newline at end of file diff --git a/src/app/models/__init__.py b/src/app/models/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app/models/schemas.py b/src/app/models/schemas.py new file mode 100644 index 00000000..48a7476c --- /dev/null +++ b/src/app/models/schemas.py @@ -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 \ No newline at end of file diff --git a/src/app/storage/__init__.py b/src/app/storage/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app/storage/memory.py b/src/app/storage/memory.py new file mode 100644 index 00000000..dabfbdbb --- /dev/null +++ b/src/app/storage/memory.py @@ -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() # единственный экземпляр хранилища на процесс \ No newline at end of file diff --git a/student-tests/run_all.py b/student-tests/run_all.py new file mode 100644 index 00000000..02e2e007 --- /dev/null +++ b/student-tests/run_all.py @@ -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() \ No newline at end of file diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 00000000..f8f90c12 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -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) \ No newline at end of file diff --git a/student-tests/test_load_track1.py b/student-tests/test_load_track1.py new file mode 100644 index 00000000..7256a8b9 --- /dev/null +++ b/student-tests/test_load_track1.py @@ -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) \ No newline at end of file diff --git a/student-tests/test_negative.py b/student-tests/test_negative.py new file mode 100644 index 00000000..2564c3ff --- /dev/null +++ b/student-tests/test_negative.py @@ -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) \ No newline at end of file