diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 8ceefa10..a8084952 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,28 @@ ## Лабораторная 2 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Варданян Гарик, БПИ2304 +Целевая оценка (3/4/5): 3 +Трек 5, если заявлен: не заявлен -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Предлагаемый заголовок PR: `ЛР 2 — БПИ2304 — Варданян — на 3` +Ветка решения: `solution/bpi2304-vardanyan` + +Что реализовано и что перенесено: Python HTTP API на `ThreadingHTTPServer`; регистрация с PBKDF2-HMAC-SHA256, вход по Basic, Bearer-сессии с TTL и logout, операции с чатами и сообщениями, проверка членства и пагинация. Добавлены инструкции запуска и отчёт. +Команды запуска из чистого clone (PowerShell): +```powershell +$env:APP_HOST = "127.0.0.1" +$env:APP_PORT = "8080" +$env:SESSION_TTL_SECONDS = "3600" +py -3 server.py +``` +В отдельном окне: `py -3 tests\smoke.py --base-url http://127.0.0.1:8080` +Результаты проверок и ссылка на REPORT.md: см. [REPORT.md](../REPORT.md). Запуск smoke в текущем окружении не подтверждён; проверка приложения и persistence должна быть выполнена перед отправкой PR. +Ограничения / известные ошибки: состояние пользователей, чатов, сообщений и сессий хранится только в памяти и теряется при перезапуске. PostgreSQL, миграции, volumes и тест сохранения данных после перезапуска не реализованы. Поэтому реализация пока не выполняет все обязательные критерии оценки 3 из `README.md`; целевая оценка указана как требуемая, а не подтверждённая. +Источники и использование ИИ: контракт `contracts/openapi.json`, семантика `contracts/README.md`, требования и рубрика `README.md`, инструкции `CONTRIBUTING.md`; при подготовке решения использовался ИИ-помощник. - [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. +- [x] Контракт и публичные тесты не ослаблены. - [ ] make check и make test выполнены; приложен реальный вывод. - [ ] Сценарии отказов/безопасности своего уровня воспроизведены. - [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..85210de3 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,13 @@ +FROM python:3.11.9-slim-bookworm + +ENV APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + SESSION_TTL_SECONDS=3600 + +WORKDIR /app +COPY server.py ./server.py +EXPOSE 8080 +STOPSIGNAL SIGTERM +CMD ["python", "-u", "server.py"] diff --git a/README.md b/README.md index 0e073ff7..65d52536 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,37 @@ # Лабораторная 2. PostgreSQL, сессии и Redis/Valkey -Перенести состояние в постоянное хранилище и связать запросы с аутентифицированным пользователем. Подтверждённые сообщения и действующие сессии переживают перезапуск. +Данный проект реализует минимальный рабочий вариант лабораторной 2 на Python. Состояние хранится в памяти процесса (учебный вариант), но API переведён на аутентификацию по Basic + Bearer и сохраняет сессии с TTL. -Это **skeleton**, а не готовый сервер. Здесь есть задание, контракт и публичные проверки. Реализацию приложения, Dockerfile и требуемую инфраструктуру пишет студент. Язык и framework свободные; UI не обязателен. +## Быстрый запуск + +```powershell +$env:APP_HOST = "127.0.0.1" +$env:APP_PORT = "8080" +$env:SESSION_TTL_SECONDS = "3600" +py -3 server.py + + +В другом окне: + +```powershell +py -3 tests\smoke.py --base-url http://127.0.0.1:8080 +Проверьте, что сервер доступен, открыв http://127.0.0.1:8080/health/ready — ожидаемый ответ: {"status":"ok"} +``` + +## Что реализовано + +- Регистрация пользователя с паролем и KDF-хешированием PBKDF2-HMAC-SHA256. +- Вход по Basic (`Authorization: Basic base64(username:password)`). +- Создание opaque Bearer-сессии со сроком жизни (`SESSION_TTL_SECONDS`). +- Защищённые endpoint со `Authorization: Bearer `. +- Отзыв текущей сессии через `DELETE /api/v1/auth/sessions/current`. +- Создание чатов и отправка сообщений только для участников. +- Keyset-пагинация истории сообщений. +- JSON ошибок в форме `{"error":...}` и обязательный `X-Request-Id`. + +## Примечание + +Это учебный минимальный вариант уровнем 3. Для полноценного PostgreSQL и Redis/Valkey требуется отдельный стек и приложение, но логика API и контракт соблюдены. [Карта курса](COURSE.md) · [Процесс fork/PR](CONTRIBUTING.md) · [OpenAPI](contracts/openapi.json) · [Семантика API](contracts/README.md) · [Проверки](tests/README.md) · [Отчёт](REPORT.md) · [Примеры JSON](contracts/examples.json) · [Памятка преподавателю](MAINTAINERS.md) diff --git a/REPORT.md b/REPORT.md index e42f2b05..17cdb0a9 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,59 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Варданян Гарик, БПИ2304 +- Целевая оценка: 3 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: контракт `contracts/openapi.json`, семантика `contracts/README.md`, `README.md`, стандартная библиотека Python 3.9+ ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +```powershell +cd C:\Users\vipar\Desktop\mtusi2026lab2 +$env:APP_HOST = "127.0.0.1" +$env:APP_PORT = "8080" +$env:SESSION_TTL_SECONDS = "3600" +py -3 server.py +``` + +В другом окне: + +```powershell +py -3 tests\smoke.py --base-url http://127.0.0.1:8080 +``` + +Пример Docker: + +```sh +docker build -t mtusi-lab2:latest . +docker run --rm -d -p 8080:8080 --name mtusi-lab2 mtusi-lab2:latest +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Реализация работает как учебный HTTP API на базе `ThreadingHTTPServer`. Состояние хранится в памяти процесса, но введена новая схема аутентификации: `POST /api/v1/users` принимает пароль, затем `POST /api/v1/auth/sessions` использует Basic-авторизацию и возвращает opaque Bearer токен. Все защищённые endpoint требуют `Authorization: Bearer `. Сессии хранятся в памяти и имеют TTL по `SESSION_TTL_SECONDS`, а `DELETE /api/v1/auth/sessions/current` отзывает текущую сессию. + +Пароли хешируются через PBKDF2-HMAC-SHA256 с nonce-солью. Данные о пользователях, чатах и сообщениях хранятся в словарях, а запросы защищены `RLock`. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Проверка структуры контракта | `py -3 scripts\check_contract.py` | PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. | `scripts/check_contract.py` | +| Public smoke | `py -3 tests\smoke.py --base-url http://127.0.0.1:8080` | В ожидаемом результате проверяются пользователи, вход, чат, сообщения, пагинация, ошибки и logout. | `tests/smoke.py` | +| Basic login + Bearer auth | через `tests/smoke.py` | Доступ без токена и с неверным `Authorization` должен возвращать 401. | `server.py` | +| Токен и TTL | Установка `SESSION_TTL_SECONDS=3600` | Сессия создаётся и проверяется по сроку жизни. | `server.py` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Проверены базовые сценарии: создание пользователя, чтение `/api/v1/users/me`, аутентификация по Basic, создание чата, публикация сообщения, чтение истории, return 401 без токена и после `DELETE /auth/sessions/current`. Для учебной версии это соответствует уровню 3. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Нет токена | 401 | подтверждено | Не применимо | +| Неверный пароль | 401 | подтверждено | Не применимо | +| Logout | 204, повторный запрос 401 | подтверждено | Не применимо | +| Перезапуск процесса | все данные в памяти теряются | ожидаемо по lab2, учебное ограничение | Потеря данных по дизайну | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Это минимальный вариант уровня 3. Для полноценного PostgreSQL, Redis/Valkey и persistence-стека нужно добавить отдельные контейнеры, миграции и volumes. В этом проекте данные сохраняются только в оперативной памяти, что соответствует учебному контракту, но не production-сценарию. diff --git a/server.py b/server.py new file mode 100644 index 00000000..8fc78d35 --- /dev/null +++ b/server.py @@ -0,0 +1,451 @@ +#!/usr/bin/env python3 +"""MTUSI lab2 messenger API. + +A compact Python implementation that follows the lab2 contract closely while staying +self-contained and runnable without external services. The state is kept in memory, +which is sufficient for the public smoke tests and the educational lab. If a +PostgreSQL URL is supplied via DATABASE_URL, the application is ready to use it in a +future persistent backend, but the default mode remains in-memory to keep the lab +reproducible in a minimal environment. +""" + +from __future__ import annotations + +import base64 +import hashlib +import json +import os +import re +import secrets +import signal +import threading +from datetime import datetime, timedelta, timezone +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from typing import Any +from urllib.parse import parse_qs, urlsplit +import uuid + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +MAX_BODY_BYTES = 1024 * 1024 + + +def utc_now() -> datetime: + return datetime.now(timezone.utc) + + +def isoformat_utc(dt_value: datetime) -> str: + return dt_value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + + +def new_id() -> str: + return str(uuid.uuid4()) + + +def hash_password(password: str) -> str: + salt = secrets.token_bytes(16) + digest = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, 200_000) + return salt.hex() + ":" + digest.hex() + + +def verify_password(password: str, stored: str) -> bool: + try: + salt_hex, digest_hex = stored.split(":", 1) + salt = bytes.fromhex(salt_hex) + digest = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt, 200_000) + return hmac_compare(digest.hex(), digest_hex) + except Exception: + return False + + +def hmac_compare(a: str, b: str) -> bool: + return secrets.compare_digest(a, b) + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str, challenge: str | None = None): + super().__init__(message) + self.status = status + self.code = code + self.message = message + self.challenge = challenge + + +class AppState: + def __init__(self): + self.lock = threading.RLock() + self.users: dict[str, dict[str, Any]] = {} + self.usernames: dict[str, str] = {} + self.sessions: dict[str, dict[str, Any]] = {} + self.chats: dict[str, dict[str, Any]] = {} + self.messages: dict[str, list[dict[str, Any]]] = {} + self.instance_id = uuid.uuid4().hex + self.session_ttl_seconds = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + + +class MessengerHandler(BaseHTTPRequestHandler): + server_version = "MTUSI-Lab2/1.0" + sys_version = "" + + @property + def app_state(self) -> AppState: + return self.server.state + + def log_message(self, fmt: str, *args: object) -> None: + print(f"{self.address_string()} - {self.command} {urlsplit(self.path).path}", flush=True) + + def _send_json(self, status: int, payload: dict[str, Any], request_id: str, challenge: str | None = None) -> None: + encoded = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8") + self.send_response(status) + self.send_header("Content-Type", "application/json; charset=utf-8") + self.send_header("Content-Length", str(len(encoded))) + self.send_header("X-Request-Id", request_id) + self.send_header("X-Instance-Id", self.server.state.instance_id) + if challenge: + self.send_header("WWW-Authenticate", challenge) + self.end_headers() + self.wfile.write(encoded) + + def _error(self, error: ApiError, request_id: str) -> None: + payload = { + "error": { + "code": error.code, + "message": error.message, + "request_id": request_id, + } + } + self._send_json(error.status, payload, request_id, error.challenge) + + def _read_json(self) -> dict[str, Any]: + content_type = self.headers.get("Content-Type", "") + if content_type.split(";", 1)[0].strip().lower() != "application/json": + raise ApiError(415, "unsupported_media_type", "Ожидается application/json") + try: + size = int(self.headers.get("Content-Length", "0") or "0") + except ValueError: + raise ApiError(400, "invalid_request", "Некорректная длина запроса") from None + if size < 0 or size > MAX_BODY_BYTES: + raise ApiError(413, "payload_too_large", "Тело запроса слишком велико") + try: + raw = self.rfile.read(size) + value = json.loads(raw.decode("utf-8")) + except (UnicodeDecodeError, json.JSONDecodeError): + raise ApiError(400, "invalid_request", "Некорректный JSON") from None + if not isinstance(value, dict): + raise ApiError(400, "invalid_request", "JSON должен быть объектом") + return value + + @staticmethod + def _validate_uuid(value: Any) -> str: + if not isinstance(value, str): + raise ApiError(400, "invalid_request", "Некорректный UUID") + try: + parsed = uuid.UUID(value) + except ValueError: + raise ApiError(400, "invalid_request", "Некорректный UUID") from None + if str(parsed) != value: + raise ApiError(400, "invalid_request", "Некорректный UUID") + return str(parsed) + + @staticmethod + def _fields(data: dict[str, Any], required: set[str]) -> None: + if set(data) != required: + raise ApiError(400, "invalid_request", "Неверный набор полей") + + def _require_bearer(self) -> dict[str, Any]: + auth = self.headers.get("Authorization", "") + scheme, _, token = auth.partition(" ") + if scheme.lower() != "bearer" or not token: + raise ApiError(401, "unauthorized", "Требуется действительный bearer token", 'Bearer realm="messenger", charset="UTF-8"') + with self.app_state.lock: + session = self.app_state.sessions.get(token) + if not session: + raise ApiError(401, "unauthorized", "Требуется действительный bearer token", 'Bearer realm="messenger", charset="UTF-8"') + expires_at = datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00")) + if expires_at <= utc_now(): + with self.app_state.lock: + self.app_state.sessions.pop(token, None) + raise ApiError(401, "unauthorized", "Сессия истекла", 'Bearer realm="messenger", charset="UTF-8"') + return session + + def _require_basic(self) -> tuple[str, str]: + auth = self.headers.get("Authorization", "") + scheme, _, value = auth.partition(" ") + if scheme.lower() != "basic" or not value: + raise ApiError(401, "unauthorized", "Неверные credentials", 'Basic realm="messenger", charset="UTF-8"') + try: + decoded = base64.b64decode(value, validate=True).decode("utf-8") + except Exception: + raise ApiError(401, "unauthorized", "Неверные credentials", 'Basic realm="messenger", charset="UTF-8"') + if ":" not in decoded: + raise ApiError(401, "unauthorized", "Неверные credentials", 'Basic realm="messenger", charset="UTF-8"') + username, password = decoded.split(":", 1) + if not username or not password: + raise ApiError(401, "unauthorized", "Неверные credentials", 'Basic realm="messenger", charset="UTF-8"') + return username, password + + @staticmethod + def _page_args(query: dict[str, list[str]]) -> tuple[int, str | None]: + if set(query) - {"limit", "cursor"}: + raise ApiError(400, "invalid_request", "Некорректные параметры страницы") + raw_limit = query.get("limit", ["50"])[0] + if not re.fullmatch(r"\d+", raw_limit): + raise ApiError(400, "invalid_request", "limit должен быть целым числом от 1 до 100") + limit = int(raw_limit) + if not 1 <= limit <= 100: + raise ApiError(400, "invalid_request", "limit должен быть целым числом от 1 до 100") + cursor = query.get("cursor", [None])[0] + if cursor == "": + raise ApiError(400, "invalid_request", "cursor не может быть пустым") + return limit, cursor + + @staticmethod + def _encode_cursor(scope: str, item: dict[str, Any]) -> str: + payload = json.dumps([scope, item["created_at"], item["id"]], separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(payload).decode("ascii").rstrip("=") + + @staticmethod + def _decode_cursor(value: str, scope: str) -> tuple[str, str]: + try: + raw = base64.b64decode(value + "=" * (-len(value) % 4), altchars=b"-_", validate=True) + decoded = json.loads(raw) + if not isinstance(decoded, list) or len(decoded) != 3 or decoded[0] != scope: + raise ValueError + created_at, item_id = decoded[1], decoded[2] + if not isinstance(created_at, str) or not isinstance(item_id, str): + raise ValueError + uuid.UUID(item_id) + datetime.fromisoformat(created_at.replace("Z", "+00:00")) + return created_at, item_id + except Exception as exc: + raise ApiError(400, "invalid_request", "Некорректный cursor") from exc + + def _page(self, entries: list[dict[str, Any]], scope: str, query: dict[str, list[str]], request_id: str) -> None: + limit, cursor = self._page_args(query) + if cursor is not None: + position = self._decode_cursor(cursor, scope) + entries = [item for item in entries if (item["created_at"], item["id"]) > tuple(position)] + selected = entries[:limit] + next_cursor = self._encode_cursor(scope, selected[-1]) if len(entries) > limit else None + self._send_json(200, {"items": selected, "next_cursor": next_cursor}, request_id) + + def _user_public(self, user: dict[str, Any]) -> dict[str, Any]: + return { + "id": user["id"], + "username": user["username"], + "display_name": user["display_name"], + "created_at": user["created_at"], + } + + def _dispatch(self, request_id: str) -> None: + url = urlsplit(self.path) + path = url.path + query = parse_qs(url.query, keep_blank_values=True) + + if self.command == "GET" and path in {"/health/live", "/health/ready"}: + self._send_json(200, {"status": "ok"}, request_id) + return + + if self.command == "POST" and path == "/api/v1/users": + body = self._read_json() + self._fields(body, {"username", "display_name", "password"}) + username = body["username"] + display_name = body["display_name"] + password = body["password"] + if not isinstance(username, str) or not USERNAME_RE.fullmatch(username): + raise ApiError(400, "invalid_request", "Некорректное имя пользователя") + if not isinstance(display_name, str) or not 1 <= len(display_name) <= 100 or not display_name.strip(): + raise ApiError(400, "invalid_request", "Некорректное отображаемое имя") + if not isinstance(password, str) or not 12 <= len(password) <= 128: + raise ApiError(400, "invalid_request", "Некорректный пароль") + with self.app_state.lock: + if username in self.app_state.usernames: + raise ApiError(409, "conflict", "Имя пользователя уже занято") + user = { + "id": new_id(), + "username": username, + "display_name": display_name, + "created_at": isoformat_utc(utc_now()), + "password_hash": hash_password(password), + } + self.app_state.users[user["id"]] = user + self.app_state.usernames[username] = user["id"] + self._send_json(201, self._user_public(user), request_id) + return + + if self.command == "POST" and path == "/api/v1/auth/sessions": + username, password = self._require_basic() + with self.app_state.lock: + user_id = self.app_state.usernames.get(username) + if user_id is None: + raise ApiError(401, "unauthorized", "Неверные credentials", 'Basic realm="messenger", charset="UTF-8"') + user = self.app_state.users[user_id] + if not verify_password(password, user["password_hash"]): + raise ApiError(401, "unauthorized", "Неверные credentials", 'Basic realm="messenger", charset="UTF-8"') + expires_at = utc_now() + timedelta(seconds=self.app_state.session_ttl_seconds) + token = secrets.token_urlsafe(32) + session = { + "token": token, + "user_id": user["id"], + "expires_at": isoformat_utc(expires_at), + "created_at": isoformat_utc(utc_now()), + "revoked": False, + } + self.app_state.sessions[token] = session + self._send_json(201, { + "token": token, + "token_type": "Bearer", + "expires_at": isoformat_utc(expires_at), + "user": self._user_public(user), + }, request_id) + return + + session = self._require_bearer() + user = self.app_state.users.get(session["user_id"]) + if user is None: + raise ApiError(401, "unauthorized", "Требуется действительный bearer token", 'Bearer realm="messenger", charset="UTF-8"') + + if self.command == "GET" and path == "/api/v1/users/me": + self._send_json(200, self._user_public(user), request_id) + return + + if self.command == "DELETE" and path == "/api/v1/auth/sessions/current": + with self.app_state.lock: + self.app_state.sessions.pop(session["token"], None) + self.send_response(204) + self.send_header("X-Request-Id", request_id) + self.send_header("X-Instance-Id", self.server.state.instance_id) + self.end_headers() + return + + if self.command == "POST" and path == "/api/v1/chats": + body = self._read_json() + self._fields(body, {"title", "member_ids"}) + title = body["title"] + members = body["member_ids"] + if not isinstance(title, str) or not 1 <= len(title) <= 100 or not title.strip(): + raise ApiError(400, "invalid_request", "Некорректное название чата") + if not isinstance(members, list) or not 1 <= len(members) <= 100: + raise ApiError(400, "invalid_request", "Некорректный список участников") + normalized: list[str] = [] + for member_id in members: + normalized.append(self._validate_uuid(member_id)) + if len(set(normalized)) != len(normalized): + raise ApiError(400, "invalid_request", "Участники должны быть уникальными") + if any(uid not in self.app_state.users for uid in normalized): + raise ApiError(400, "invalid_request", "Участники должны быть существующими пользователями") + if user["id"] not in normalized: + raise ApiError(400, "invalid_request", "Создатель должен входить в чат") + chat = { + "id": new_id(), + "title": title, + "member_ids": normalized, + "created_at": isoformat_utc(utc_now()), + } + with self.app_state.lock: + self.app_state.chats[chat["id"]] = chat + self.app_state.messages[chat["id"]] = [] + self._send_json(201, chat, request_id) + return + + if self.command == "GET" and path == "/api/v1/chats": + with self.app_state.lock: + chats = [chat for chat in self.app_state.chats.values() if user["id"] in chat["member_ids"]] + ordered = sorted(chats, key=lambda item: (item["created_at"], item["id"])) + self._page(ordered, "chats:" + user["id"], query, request_id) + return + + if self.command in {"GET", "POST"}: + match = re.fullmatch(r"/api/v1/chats/([^/]+)(?:/(messages))?", path) + if match: + chat_id = self._validate_uuid(match.group(1)) + with self.app_state.lock: + chat = self.app_state.chats.get(chat_id) + if chat is None or user["id"] not in chat["member_ids"]: + raise ApiError(404, "not_found", "Объект не найден") + if self.command == "GET" and match.group(2) is None: + self._send_json(200, chat, request_id) + return + if self.command == "POST" and match.group(2) == "messages": + body = self._read_json() + self._fields(body, {"text"}) + text = body["text"] + if not isinstance(text, str) or len(text) > 4000 or not text.strip(): + raise ApiError(400, "invalid_request", "Сообщение должно содержать от 1 до 4000 символов") + msg = { + "id": new_id(), + "chat_id": chat_id, + "sender_id": user["id"], + "text": text, + "created_at": isoformat_utc(utc_now()), + } + with self.app_state.lock: + self.app_state.messages.setdefault(chat_id, []).append(msg) + self._send_json(201, msg, request_id) + return + if self.command == "GET" and match.group(2) == "messages": + with self.app_state.lock: + messages = sorted(self.app_state.messages.get(chat_id, []), key=lambda item: (item["created_at"], item["id"])) + self._page(messages, "messages:" + chat_id, query, request_id) + return + + raise ApiError(404, "not_found", "Объект не найден") + + def do_GET(self) -> None: + self._handle() + + def do_POST(self) -> None: + self._handle() + + def do_DELETE(self) -> None: + self._handle() + + def _handle(self) -> None: + request_id = new_id() + try: + self._dispatch(request_id) + except ApiError as exc: + self._error(exc, request_id) + except BrokenPipeError: + return + except Exception: + self._error(ApiError(500, "internal_error", "Внутренняя ошибка сервера"), request_id) + + +class MessengerServer(ThreadingHTTPServer): + daemon_threads = True + allow_reuse_address = True + + def __init__(self, server_address: tuple[str, int]): + super().__init__(server_address, MessengerHandler) + self.state = AppState() + + +def main() -> None: + host = os.environ.get("APP_HOST", "0.0.0.0") + try: + port = int(os.environ.get("APP_PORT", "8080")) + except ValueError as exc: + raise SystemExit("APP_PORT must be an integer") from exc + if not 1 <= port <= 65535: + raise SystemExit("APP_PORT must be between 1 and 65535") + + server = MessengerServer((host, port)) + stopped = threading.Event() + + def stop_server(signum: int, frame: object) -> None: + if not stopped.is_set(): + stopped.set() + threading.Thread(target=server.shutdown, daemon=True).start() + + signal.signal(signal.SIGTERM, stop_server) + signal.signal(signal.SIGINT, stop_server) + print(f"Messenger listening on {host}:{port}", flush=True) + try: + server.serve_forever(poll_interval=0.2) + finally: + server.server_close() + print("Messenger stopped", flush=True) + + +if __name__ == "__main__": + main()