diff --git a/.dockerignore b/.dockerignore index bc16e556..4741db61 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,4 +1,9 @@ .git +.venv +__pycache__ +*.pyc +.env +evidence.git .github .env .env.* @@ -16,5 +21,4 @@ backups .venv __pycache__ node_modules -evidence -.DS_Store +evidence \ No newline at end of file diff --git a/.env.example b/.env.example index 714c8076..cb446618 100644 --- a/.env.example +++ b/.env.example @@ -9,3 +9,4 @@ DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: SESSION_STORE=postgres CACHE_URL_FILE=/run/secrets/cache_url +POSTGRES_PASSWORD=replace-with-a-local-password diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..81a3be8c --- /dev/null +++ b/Dockerfile @@ -0,0 +1,15 @@ +FROM python:3.12.7-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 +WORKDIR /app + +COPY app.py server.py . +COPY messenger ./messenger +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt +RUN useradd --create-home --uid 10001 appuser +USER appuser + +EXPOSE 8080 +HEALTHCHECK --interval=10s --timeout=3s --start-period=2s --retries=3 CMD python -c "from urllib.request import urlopen; urlopen('http://127.0.0.1:8080/health/ready', timeout=2)" +CMD ["python", "server.py"] \ No newline at end of file diff --git a/Makefile b/Makefile index 9ecb223e..c597be87 100644 --- a/Makefile +++ b/Makefile @@ -1,10 +1,16 @@ PYTHON ?= python3 -BASE_URL ?= http://localhost:8080 +BASE_URL ?= http://127.0.0.1:8080 +CONTAINER_NAME ?= mtusi-messenger-lab1 CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) +ifeq ($(OS),Windows_NT) +PERSISTENCE_SCRIPT ?= scripts/restart.cmd +else +PERSISTENCE_SCRIPT ?= $(ACTION_SCRIPT) +endif -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test test-unit test-persistence test-lifecycle load help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -18,9 +24,14 @@ validate: test: $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) -load: - $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) - test-persistence: - @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) - $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + $(PYTHON) tests/resilience.py --base-url "$(BASE_URL)" --mode persistence --action-script "$(PERSISTENCE_SCRIPT)" $(TLS_ARGS) + +test-unit: + $(PYTHON) -m unittest discover -s tests -p "test_*.py" -v + +test-lifecycle: + $(PYTHON) tests/demo_lifecycle.py --base-url "$(BASE_URL)" --container "$(CONTAINER_NAME)" + +load: + $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..2366b3ab 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,24 +1,33 @@ # Отчёт — лабораторная 2 - Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Целевая оценка; выбранный трек 5, если нужен: 3 - Commit/PR: TODO после публикации - Использованные источники, библиотеки и помощь ИИ: TODO ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Engine и Compose. Скопируйте `.env.example` в `.env` и задайте локальный +`POSTGRES_PASSWORD` (файл `.env` не коммитится). Запуск: `docker compose up -d --build`; API автоматически создаёт +схему PostgreSQL при старте. Проверка: `make test`. Перезапуск с сохранением данных: +`make test-persistence ACTION_SCRIPT=scripts/restart.sh` (в Windows Makefile автоматически +использует `scripts/restart.cmd`). Остановка без удаления данных: +`docker compose down`; намеренное удаление учебных данных: `docker compose down -v`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +API работает в контейнере `api`, PostgreSQL является источником истины для пользователей, +чатов, membership, сообщений и сессий; volume `postgres_data` сохраняется. Схема создаётся +идемпотентными `CREATE TABLE IF NOT EXISTS`, операции создания чата записывают чат и membership +под блокировкой состояния. В lab2 X-User-Id заменён на Basic только для входа и Bearer для API. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | +| Публичный smoke | make test | PASS после запуска Compose | tests/smoke.py | +| PostgreSQL и persistence | make test-persistence ACTION_SCRIPT=scripts/restart.sh | тот же токен и данные после restart | compose.yaml, scripts/restart.sh | +| Auth, expiry, logout | tests/smoke.py | Basic/Bearer, 401 после logout | messenger/service.py | | Все пункты уровня 4, если заявлен | TODO | TODO | TODO | | Выбранный трек 5, если заявлен | TODO | TODO | TODO | diff --git a/app.py b/app.py new file mode 100644 index 00000000..c21eeab6 --- /dev/null +++ b/app.py @@ -0,0 +1,21 @@ +"""Compatibility entry point and test imports for the modular messenger.""" + +from http.server import ThreadingHTTPServer + +from messenger.http import make_handler +from messenger.service import MessengerService +from messenger.state import State + + +state = State() +service = MessengerService(state) +Handler = make_handler(service) + + +def main(): + from server import main as run_server + run_server() + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..c06e74db --- /dev/null +++ b/compose.yaml @@ -0,0 +1,29 @@ +services: + postgres: + image: postgres:16.4 + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Create .env from .env.example} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 20 + api: + build: . + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@postgres:5432/messenger + SESSION_TTL_SECONDS: 3600 + ports: + - "8080:8080" + depends_on: + postgres: + condition: service_healthy + restart: unless-stopped +volumes: + postgres_data: diff --git a/messenger/_init_.py b/messenger/_init_.py new file mode 100644 index 00000000..99838512 --- /dev/null +++ b/messenger/_init_.py @@ -0,0 +1 @@ +"""In-memory messenger application.""" \ No newline at end of file diff --git a/messenger/domain.py b/messenger/domain.py new file mode 100644 index 00000000..896b1a2c --- /dev/null +++ b/messenger/domain.py @@ -0,0 +1,29 @@ +import json +import re +from datetime import datetime, timezone + + +UUID_RE = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$") +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + + +def now(): + return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z") + + +def compact_json(value): + return json.dumps(value, ensure_ascii=False, separators=(",", ":")) + + +def require_uuid(value): + return isinstance(value, str) and UUID_RE.fullmatch(value) is not None + + +def validate_object(body, allowed, required): + if not isinstance(body, dict) or set(body) - set(allowed) or not set(required).issubset(body): + from .errors import ApiError + raise ApiError(400, "invalid_request", "Неверный формат запроса") + + +def validate_text(value, maximum): + return isinstance(value, str) and value.strip() and len(value) <= maximum \ No newline at end of file diff --git a/messenger/errors.py b/messenger/errors.py new file mode 100644 index 00000000..28500e8b --- /dev/null +++ b/messenger/errors.py @@ -0,0 +1,5 @@ +class ApiError(Exception): + def __init__(self, status, code, message): + self.status = status + self.code = code + self.message = message \ No newline at end of file diff --git a/messenger/http.py b/messenger/http.py new file mode 100644 index 00000000..c2a8a98f --- /dev/null +++ b/messenger/http.py @@ -0,0 +1,104 @@ +import json +import logging +import re +import uuid +from http.server import BaseHTTPRequestHandler +from urllib.parse import parse_qs, urlparse + +from .domain import compact_json +from .errors import ApiError +from .service import MessengerService + + +def make_handler(service: MessengerService): + class Handler(BaseHTTPRequestHandler): + server_version = "Messenger/1.0" + + def log_message(self, fmt, *args): + logging.info("%s %s", self.command, self.path.split("?", 1)[0]) + + def send_json(self, status, payload, headers=None): + request_id = str(uuid.uuid4()) + if status >= 400 and isinstance(payload, dict) and "error" in payload: + payload["error"]["request_id"] = request_id + data = compact_json(payload).encode("utf-8") + if status == 204: + data = b"" + self.send_response(status) + self.send_header("Content-Type", "application/json; charset=utf-8") + self.send_header("Content-Length", str(len(data))) + self.send_header("X-Request-Id", request_id) + for key, value in (headers or {}).items(): + self.send_header(key, value) + self.end_headers() + if status != 204: + self.wfile.write(data) + + def send_error_json(self, error): + headers = {} + if error.status == 401: + if self.path.split("?", 1)[0] == "/api/v1/auth/sessions": + headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"' + else: + headers["WWW-Authenticate"] = 'Bearer realm="messenger"' + self.send_json(error.status, {"error": {"code": error.code, "message": error.message, "request_id": ""}}, headers) + + def read_json(self): + if self.headers.get_content_type() != "application/json": + raise ApiError(400, "invalid_request", "Ожидается application/json") + try: + length = int(self.headers.get("Content-Length", "-1")) + if length < 0 or length > 1024 * 1024: + raise ValueError + return json.loads(self.rfile.read(length).decode("utf-8")) + except (ValueError, UnicodeDecodeError, json.JSONDecodeError): + raise ApiError(400, "invalid_request", "Некорректный JSON") + + def route(self): + parsed = urlparse(self.path) + path = parsed.path + query = parse_qs(parsed.query, keep_blank_values=True) + if self.command == "GET" and path in ("/health/live", "/health/ready"): + return self.send_json(200, {"status": "ok"}) + if self.command == "POST" and path == "/api/v1/users": + return self.send_json(201, service.create_user(self.read_json())) + if self.command == "POST" and path == "/api/v1/auth/sessions": + return self.send_json(201, service.create_session(self.headers.get("Authorization", ""))) + if self.command == "DELETE" and path == "/api/v1/auth/sessions/current": + service.revoke_session(self.headers) + return self.send_json(204, None) + if path == "/api/v1/users/me" and self.command == "GET": + return self.send_json(200, service.current_user(self.headers)) + if path == "/api/v1/chats" and self.command == "POST": + return self.send_json(201, service.create_chat(self.headers, self.read_json())) + if path == "/api/v1/chats" and self.command == "GET": + return self.send_json(200, service.list_chats(self.headers, query)) + match = re.fullmatch(r"/api/v1/chats/([^/]+)", path) + if match and self.command == "GET": + return self.send_json(200, service.get_chat(self.headers, match.group(1))) + match = re.fullmatch(r"/api/v1/chats/([^/]+)/messages", path) + if match and self.command == "POST": + return self.send_json(201, service.create_message(self.headers, match.group(1), self.read_json())) + if match and self.command == "GET": + return self.send_json(200, service.list_messages(self.headers, match.group(1), query)) + raise ApiError(404, "not_found", "Объект не найден") + + def do_GET(self): + self.handle_request() + + def do_POST(self): + self.handle_request() + + def do_DELETE(self): + self.handle_request() + + def handle_request(self): + try: + self.route() + except ApiError as error: + self.send_error_json(error) + except Exception: + logging.exception("request failed") + self.send_error_json(ApiError(500, "internal_error", "Внутренняя ошибка")) + + return Handler \ No newline at end of file diff --git a/messenger/service.py b/messenger/service.py new file mode 100644 index 00000000..c9539874 --- /dev/null +++ b/messenger/service.py @@ -0,0 +1,226 @@ +import base64 +import binascii +import hashlib +import hmac +import os +import secrets +import time +import uuid +from datetime import datetime, timezone + +from .domain import USERNAME_RE, now, require_uuid, validate_object, validate_text +from .errors import ApiError +from .state import State + + +class MessengerService: + def __init__(self, state: State): + self.state = state + + def actor(self, headers): + authorization = headers.get("Authorization", "") + if not authorization.startswith("Bearer "): + raise ApiError(401, "unauthorized", "Требуется Bearer-сессия") + token = authorization[7:].strip() + with self.state.lock: + session = self.state.sessions.get(token) + user = self.state.users.get(session["user_id"]) if session else None + if session and (session["revoked"] or session["expires_at"] <= time.time()): + user = None + if not user: + raise ApiError(401, "unauthorized", "Требуется действительная сессия") + return user + + @staticmethod + def public_user(user): + return {key: value for key, value in user.items() if not key.startswith("_")} + + @staticmethod + def _password_hash(password): + salt = secrets.token_bytes(16) + digest = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=16384, r=8, p=1) + return "scrypt$16384$8$1$%s$%s" % (salt.hex(), digest.hex()) + + @staticmethod + def _password_matches(password, encoded): + try: + _, n, r, p, salt, digest = encoded.split("$") + actual = hashlib.scrypt(password.encode("utf-8"), salt=bytes.fromhex(salt), + n=int(n), r=int(r), p=int(p)) + return hmac.compare_digest(actual.hex(), digest) + except (ValueError, TypeError): + return False + + def create_user(self, body): + validate_object(body, ("username", "display_name", "password"), ("username", "display_name", "password")) + username = body["username"] + display_name = body["display_name"] + password = body["password"] + if ( + not isinstance(username, str) + or not isinstance(display_name, str) + or not USERNAME_RE.fullmatch(username) + or not validate_text(display_name, 100) + or not isinstance(password, str) + or not 12 <= len(password) <= 128 + ): + raise ApiError(400, "invalid_request", "Некорректные данные пользователя") + with self.state.lock: + if username in self.state.usernames: + raise ApiError(409, "conflict", "Username уже занят") + user = {"id": str(uuid.uuid4()), "username": username, "display_name": display_name, + "created_at": now(), "_password_hash": self._password_hash(password)} + self.state.users[user["id"]] = user + self.state.usernames[username] = user["id"] + self.state.execute( + "INSERT INTO users (id, username, display_name, password_hash, created_at) VALUES (%s,%s,%s,%s,%s)", + (user["id"], username, display_name, user["_password_hash"], user["created_at"])) + return self.public_user(user) + + def create_session(self, authorization): + if not authorization.startswith("Basic "): + raise ApiError(401, "unauthorized", "Неверные credentials") + try: + decoded = base64.b64decode(authorization[6:], validate=True).decode("utf-8") + username, password = decoded.split(":", 1) + except (ValueError, UnicodeDecodeError, binascii.Error): + raise ApiError(401, "unauthorized", "Неверные credentials") + with self.state.lock: + user = self.state.users.get(self.state.usernames.get(username, "")) + if not user or not self._password_matches(password, user["_password_hash"]): + raise ApiError(401, "unauthorized", "Неверные credentials") + expires = time.time() + int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + token = secrets.token_urlsafe(32) + with self.state.lock: + self.state.sessions[token] = {"user_id": user["id"], "expires_at": expires, "revoked": False} + self.state.execute("INSERT INTO sessions (token,user_id,expires_at) VALUES (%s,%s,to_timestamp(%s))", + (token, user["id"], expires)) + expires_at = datetime.fromtimestamp(expires, timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z") + return {"token": token, "token_type": "Bearer", "expires_at": expires_at, + "user": self.public_user(user)} + + def revoke_session(self, headers): + authorization = headers.get("Authorization", "") + if not authorization.startswith("Bearer "): + raise ApiError(401, "unauthorized", "Требуется Bearer-сессия") + token = authorization[7:].strip() + self.actor(headers) + with self.state.lock: + self.state.sessions[token]["revoked"] = True + self.state.execute("UPDATE sessions SET revoked=TRUE WHERE token=%s", (token,)) + + def current_user(self, headers): + return self.public_user(self.actor(headers)) + + def create_chat(self, headers, body): + actor = self.actor(headers) + validate_object(body, ("title", "member_ids"), ("title", "member_ids")) + members = body["member_ids"] + if not validate_text(body["title"], 100) or not isinstance(members, list) or not 1 <= len(members) <= 100: + raise ApiError(400, "invalid_request", "Некорректные данные чата") + if not all(isinstance(item, str) and require_uuid(item) for item in members): + raise ApiError(400, "invalid_request", "Некорректный список участников") + if len(set(members)) != len(members): + raise ApiError(400, "invalid_request", "Некорректный список участников") + with self.state.lock: + if actor["id"] not in members: + raise ApiError(400, "invalid_request", "Вызывающий должен быть участником") + if any(member not in self.state.users for member in members): + raise ApiError(400, "invalid_request", "Неизвестный участник") + chat = {"id": str(uuid.uuid4()), "title": body["title"], "member_ids": members, "created_at": now()} + self.state.chats[chat["id"]] = chat + self.state.messages[chat["id"]] = [] + self.state.transaction([ + ("INSERT INTO chats (id,title,created_at) VALUES (%s,%s,%s)", + (chat["id"], chat["title"], chat["created_at"])), + ("INSERT INTO chat_members (chat_id,user_id) VALUES " + ",".join(["(%s,%s)"] * len(members)), + tuple(value for member in members for value in (chat["id"], member))), + ]) + return chat + + def accessible_chat(self, chat_id, actor): + if not require_uuid(chat_id): + raise ApiError(400, "invalid_request", "Некорректный UUID чата") + with self.state.lock: + chat = self.state.chats.get(chat_id) + if not chat or actor["id"] not in chat["member_ids"]: + raise ApiError(404, "not_found", "Объект не найден") + return chat + + def list_chats(self, headers, query): + actor = self.actor(headers) + limit = self.limit(query) + cursor = query.get("cursor", [None])[0] + with self.state.lock: + chats = [chat for chat in self.state.chats.values() if actor["id"] in chat["member_ids"]] + chats.sort(key=lambda item: (item["created_at"], item["id"])) + if cursor: + try: + padded_cursor = cursor + "=" * (-len(cursor) % 4) + cursor_time, cursor_id = base64.urlsafe_b64decode(padded_cursor.encode()).decode().split("|", 1) + except (ValueError, UnicodeDecodeError, binascii.Error): + raise ApiError(400, "invalid_request", "Некорректный cursor") + if not require_uuid(cursor_id) or not any( + item["id"] == cursor_id and item["created_at"] == cursor_time for item in chats + ): + raise ApiError(400, "invalid_request", "Cursor не принадлежит этому списку") + chats = [item for item in chats if (item["created_at"], item["id"]) > (cursor_time, cursor_id)] + page = chats[:limit] + next_cursor = None + if len(chats) > limit: + last = page[-1] + next_cursor = base64.urlsafe_b64encode( + (last["created_at"] + "|" + last["id"]).encode() + ).decode().rstrip("=") + return {"items": page, "next_cursor": next_cursor} + + def get_chat(self, headers, chat_id): + return self.accessible_chat(chat_id, self.actor(headers)) + + def create_message(self, headers, chat_id, body): + actor = self.actor(headers) + chat = self.accessible_chat(chat_id, actor) + validate_object(body, ("text",), ("text",)) + if not validate_text(body["text"], 4000): + raise ApiError(400, "invalid_request", "Сообщение не может быть пустым") + with self.state.lock: + message = {"id": str(uuid.uuid4()), "chat_id": chat["id"], "sender_id": actor["id"], "text": body["text"], "created_at": now()} + self.state.messages[chat_id].append(message) + self.state.execute( + "INSERT INTO messages (id,chat_id,sender_id,text,created_at) VALUES (%s,%s,%s,%s,%s)", + (message["id"], chat_id, actor["id"], message["text"], message["created_at"])) + return message + + def limit(self, query): + raw = query.get("limit", ["50"])[0] + try: + value = int(raw) + except ValueError: + raise ApiError(400, "invalid_request", "Некорректный limit") + if not 1 <= value <= 100: + raise ApiError(400, "invalid_request", "limit должен быть от 1 до 100") + return value + + def list_messages(self, headers, chat_id, query): + actor = self.actor(headers) + self.accessible_chat(chat_id, actor) + limit = self.limit(query) + cursor = query.get("cursor", [None])[0] + with self.state.lock: + messages = list(self.state.messages[chat_id]) + messages.sort(key=lambda item: (item["created_at"], item["id"])) + if cursor: + try: + padded_cursor = cursor + "=" * (-len(cursor) % 4) + cursor_time, cursor_id = base64.urlsafe_b64decode(padded_cursor.encode()).decode().split("|", 1) + except (ValueError, UnicodeDecodeError, binascii.Error): + raise ApiError(400, "invalid_request", "Некорректный cursor") + if not require_uuid(cursor_id) or not any(item["id"] == cursor_id and item["created_at"] == cursor_time for item in messages): + raise ApiError(400, "invalid_request", "Cursor не принадлежит этому чату") + messages = [item for item in messages if (item["created_at"], item["id"]) > (cursor_time, cursor_id)] + page = messages[:limit] + next_cursor = None + if len(messages) > limit: + last = page[-1] + next_cursor = base64.urlsafe_b64encode((last["created_at"] + "|" + last["id"]).encode()).decode().rstrip("=") + return {"items": page, "next_cursor": next_cursor} \ No newline at end of file diff --git a/messenger/state.py b/messenger/state.py new file mode 100644 index 00000000..57d8ba94 --- /dev/null +++ b/messenger/state.py @@ -0,0 +1,96 @@ +from dataclasses import dataclass, field +import os +import threading + + +SCHEMA = """ +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, username VARCHAR(32) UNIQUE NOT NULL, + display_name VARCHAR(100) NOT NULL, password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, chat_id UUID REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID REFERENCES users(id), text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); +CREATE INDEX IF NOT EXISTS messages_chat_created_idx ON messages(chat_id, created_at, id); +CREATE TABLE IF NOT EXISTS sessions ( + token TEXT PRIMARY KEY, user_id UUID REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, revoked BOOLEAN NOT NULL DEFAULT FALSE +); +""" + + +@dataclass +class State: + users: dict[str, dict] = field(default_factory=dict) + usernames: dict[str, str] = field(default_factory=dict) + chats: dict[str, dict] = field(default_factory=dict) + messages: dict[str, list[dict]] = field(default_factory=dict) + sessions: dict[str, dict] = field(default_factory=dict) + lock: threading.RLock = field(default_factory=threading.RLock) + database_url: str = field(default_factory=lambda: os.environ.get("DATABASE_URL", "")) + connection_factory: object = field(init=False, default=None) + + def __post_init__(self): + if not self.database_url: + return + try: + import psycopg + self.connection_factory = psycopg.connect + with self.connection_factory(self.database_url, autocommit=True) as conn: + with conn.cursor() as cur: + cur.execute(SCHEMA) + cur.execute("SELECT id, username, display_name, created_at, password_hash FROM users") + for row in cur.fetchall(): + user_id, username, display_name, created_at, password_hash = row + user = {"id": str(user_id), "username": username, "display_name": display_name, + "created_at": created_at.isoformat().replace("+00:00", "Z"), + "_password_hash": password_hash} + self.users[user["id"]] = user + self.usernames[username] = user["id"] + cur.execute("SELECT id, title, created_at FROM chats") + for chat_id, title, created_at in cur.fetchall(): + cur.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (chat_id,)) + self.chats[str(chat_id)] = {"id": str(chat_id), "title": title, + "member_ids": [str(row[0]) for row in cur.fetchall()], + "created_at": created_at.isoformat().replace("+00:00", "Z")} + self.messages[str(chat_id)] = [] + cur.execute("SELECT id, chat_id, sender_id, text, created_at FROM messages ORDER BY created_at, id") + for message_id, chat_id, sender_id, text, created_at in cur.fetchall(): + self.messages.setdefault(str(chat_id), []).append({ + "id": str(message_id), "chat_id": str(chat_id), "sender_id": str(sender_id), + "text": text, "created_at": created_at.isoformat().replace("+00:00", "Z")}) + cur.execute("SELECT token, user_id, expires_at, revoked FROM sessions") + for token, user_id, expires_at, revoked in cur.fetchall(): + self.sessions[token] = {"user_id": str(user_id), "expires_at": expires_at.timestamp(), + "revoked": revoked} + except ImportError as exc: + raise RuntimeError("DATABASE_URL задан, но пакет psycopg не установлен") from exc + + def execute(self, query, params=()): + if not self.connection_factory: + return + with self.connection_factory(self.database_url) as conn: + with conn.cursor() as cur: + cur.execute(query, params) + conn.commit() + + def transaction(self, statements): + if not self.connection_factory: + return + with self.connection_factory(self.database_url) as conn: + with conn.cursor() as cur: + for query, params in statements: + cur.execute(query, params) + conn.commit() diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..9550e0da --- /dev/null +++ b/requirements.txt @@ -0,0 +1 @@ +psycopg[binary]==3.2.3 diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..46f0184d --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,6 @@ +@echo off +setlocal +docker compose up -d --build --no-recreate postgres +if errorlevel 1 exit /b 1 +docker compose up -d --build api +exit /b %errorlevel% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..5794679c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +docker compose up -d --build --no-recreate postgres +docker compose up -d --build api diff --git a/server.py b/server.py new file mode 100644 index 00000000..b289480b --- /dev/null +++ b/server.py @@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +import logging +import os +import signal +import threading +from http.server import ThreadingHTTPServer + +from messenger.http import make_handler +from messenger.service import MessengerService +from messenger.state import State + + +def main(): + logging.basicConfig( + level=os.environ.get("LOG_LEVEL", "INFO"), + format="%(asctime)s %(levelname)s %(message)s", + ) + host = os.environ.get("APP_HOST", "0.0.0.0") + port = int(os.environ.get("APP_PORT", "8080")) + state = State() + service = MessengerService(state) + server = ThreadingHTTPServer((host, port), make_handler(service)) + + def stop(signum, _frame): + logging.info("received signal %s, stopping", signum) + threading.Thread(target=server.shutdown, daemon=True).start() + + signal.signal(signal.SIGTERM, stop) + signal.signal(signal.SIGINT, stop) + logging.info("messenger listening on %s:%s", host, port) + try: + server.serve_forever(poll_interval=0.2) + finally: + server.server_close() + logging.info("messenger stopped") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/tests/README.md b/tests/README.md index 0dfa3f89..e759872a 100644 --- a/tests/README.md +++ b/tests/README.md @@ -4,7 +4,7 @@ Python **3.9+**, стандартная библиотека. Сервер уж ```sh make check -make test BASE_URL=http://localhost:8080 +make test BASE_URL=http://127.0.0.1:8080 # без make: python3 tests/smoke.py --base-url http://localhost:8080 ``` diff --git a/tests/demo_lifecycle.py b/tests/demo_lifecycle.py new file mode 100644 index 00000000..7e9e86a9 --- /dev/null +++ b/tests/demo_lifecycle.py @@ -0,0 +1,90 @@ +#!/usr/bin/env python3 +"""Demonstrate that restarting lab1 clears the in-memory state.""" + +import argparse +import json +import os +import subprocess +import time +import uuid +from urllib.error import HTTPError, URLError +from urllib.request import Request, urlopen + + +def request(base_url, method, path, body=None, actor=None): + headers = {"Accept": "application/json"} + if actor: + headers["X-User-Id"] = actor + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json" + request = Request(base_url + path, data=data, headers=headers, method=method) + try: + response = urlopen(request, timeout=3) + except HTTPError as error: + response = error + with response: + payload = json.loads(response.read().decode("utf-8")) + if not response.headers.get("X-Request-Id"): + raise RuntimeError("API response is missing X-Request-Id") + return response.status, payload + + +def wait_ready(base_url, timeout=10): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + status, _ = request(base_url, "GET", "/health/ready") + if status == 200: + return + except (OSError, URLError, TimeoutError): + pass + time.sleep(0.2) + raise RuntimeError("API did not become ready within %s seconds" % timeout) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://localhost:8080")) + parser.add_argument("--container", default=os.environ.get("CONTAINER_NAME", "mtusi-messenger-lab1")) + args = parser.parse_args() + base_url = args.base_url.rstrip("/") + + username = "lifecycle_" + uuid.uuid4().hex[:12] + status, user = request(base_url, "POST", "/api/v1/users", { + "username": username, + "display_name": "Lifecycle demo", + }) + if status != 201: + raise RuntimeError("user creation returned HTTP %s" % status) + + status, chat = request(base_url, "POST", "/api/v1/chats", { + "title": "Lifecycle demo", + "member_ids": [user["id"]], + }, actor=user["id"]) + if status != 201: + raise RuntimeError("chat creation returned HTTP %s" % status) + + message_text = "persisted only while this process is alive" + status, message = request(base_url, "POST", "/api/v1/chats/%s/messages" % chat["id"], { + "text": message_text, + }, actor=user["id"]) + if status != 201: + raise RuntimeError("message creation returned HTTP %s" % status) + + status, page = request(base_url, "GET", "/api/v1/chats/%s/messages" % chat["id"], actor=user["id"]) + if status != 200 or not any(item["id"] == message["id"] for item in page["items"]): + raise RuntimeError("created message was not readable before restart") + print("before restart: user_id=%s message_id=%s message_read=yes" % (user["id"], message["id"])) + + subprocess.run(["docker", "restart", "--timeout", "5", args.container], check=True, capture_output=True, text=True) + wait_ready(base_url) + status, error = request(base_url, "GET", "/api/v1/users/me", actor=user["id"]) + if status != 401 or error.get("error", {}).get("code") != "unauthorized": + raise RuntimeError("old X-User-Id should be rejected after restart; got HTTP %s" % status) + print("after restart: old_user_id_status=%s code=%s state_reset=yes" % (status, error["error"]["code"])) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/tests/test_api.py b/tests/test_api.py new file mode 100644 index 00000000..6bb7c2ae --- /dev/null +++ b/tests/test_api.py @@ -0,0 +1,132 @@ +import json +import threading +import unittest +import urllib.error +import urllib.request + +import app + + +class ApiTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.server = app.ThreadingHTTPServer(("127.0.0.1", 0), app.Handler) + cls.thread = threading.Thread(target=cls.server.serve_forever, daemon=True) + cls.thread.start() + cls.base = "http://127.0.0.1:%d" % cls.server.server_port + + @classmethod + def tearDownClass(cls): + cls.server.shutdown() + cls.server.server_close() + + def request(self, method, path, body=None, user=None, raw=None): + headers = {"Accept": "application/json"} + if user: + headers["X-User-Id"] = user + data = raw + if body is not None: + headers["Content-Type"] = "application/json" + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + request = urllib.request.Request(self.base + path, data=data, headers=headers, method=method) + try: + response = urllib.request.urlopen(request) + except urllib.error.HTTPError as error: + response = error + with response: + payload = json.loads(response.read().decode("utf-8")) + self.assertTrue(response.headers.get("X-Request-Id")) + return response.code, payload + + def test_invalid_json_duplicate_user_and_foreign_chat(self): + status, _ = self.request("POST", "/api/v1/users", body={"username": "alice", "display_name": "Алиса"}) + self.assertEqual(status, 201) + alice_id = next(iter(app.state.users)) + status, _ = self.request("POST", "/api/v1/users", body={"username": "alice", "display_name": "Другая"}) + self.assertEqual(status, 409) + bob = self.request("POST", "/api/v1/users", body={"username": "charlie", "display_name": "Чарли"})[1] + chat = self.request("POST", "/api/v1/chats", user=alice_id, body={"title": "Тест", "member_ids": [alice_id]})[1] + status, _ = self.request("GET", "/api/v1/chats/%s" % chat["id"], user=bob["id"]) + self.assertEqual(status, 404) + status, _ = self.request("GET", "/api/v1/chats/not-a-uuid", user=alice_id) + self.assertEqual(status, 400) + status, _ = self.request("POST", "/api/v1/users", body={"username": "bad", "display_name": "x", "extra": 1}) + self.assertEqual(status, 400) + status, _ = self.request("POST", "/api/v1/users", raw=b"{broken") + self.assertEqual(status, 400) + + def test_invalid_types_and_chat_pagination(self): + status, _ = self.request("POST", "/api/v1/users", body={"username": 1, "display_name": "Тест"}) + self.assertEqual(status, 400) + user = self.request("POST", "/api/v1/users", body={"username": "typecheck", "display_name": "Типы"})[1] + for member_ids in ([{"id": user["id"]}], [user["id"], []]): + status, _ = self.request( + "POST", + "/api/v1/chats", + user=user["id"], + body={"title": "Некорректный чат", "member_ids": member_ids}, + ) + self.assertEqual(status, 400) + + for index in range(5): + status, _ = self.request( + "POST", + "/api/v1/chats", + user=user["id"], + body={"title": "Чат %d" % index, "member_ids": [user["id"]]}, + ) + self.assertEqual(status, 201) + + cursor = None + chat_ids = [] + for _ in range(5): + path = "/api/v1/chats?limit=1" + if cursor: + path += "&cursor=" + cursor + status, page = self.request("GET", path, user=user["id"]) + self.assertEqual(status, 200) + self.assertEqual(len(page["items"]), 1) + chat_ids.append(page["items"][0]["id"]) + cursor = page["next_cursor"] + self.assertIsNone(cursor) + self.assertEqual(len(set(chat_ids)), 5) + + def test_empty_message_and_multi_page_pagination(self): + user = self.request("POST", "/api/v1/users", body={"username": "pager", "display_name": "Пейджер"})[1] + chat = self.request("POST", "/api/v1/chats", user=user["id"], body={"title": "Страницы", "member_ids": [user["id"]]})[1] + status, _ = self.request("POST", "/api/v1/chats/%s/messages" % chat["id"], user=user["id"], body={"text": " "}) + self.assertEqual(status, 400) + for index in range(3): + self.assertEqual(self.request("POST", "/api/v1/chats/%s/messages" % chat["id"], user=user["id"], body={"text": str(index)})[0], 201) + status, first = self.request("GET", "/api/v1/chats/%s/messages?limit=2" % chat["id"], user=user["id"]) + self.assertEqual(status, 200) + self.assertEqual(len(first["items"]), 2) + self.assertTrue(first["next_cursor"]) + status, second = self.request("GET", "/api/v1/chats/%s/messages?limit=2&cursor=%s" % (chat["id"], first["next_cursor"]), user=user["id"]) + self.assertEqual(status, 200) + self.assertEqual(len(second["items"]), 1) + self.assertIsNone(second["next_cursor"]) + + def test_concurrent_messages_are_not_lost(self): + users = [self.request("POST", "/api/v1/users", body={"username": "client%d" % index, "display_name": "Клиент %d" % index})[1] for index in range(10)] + chat = self.request("POST", "/api/v1/chats", user=users[0]["id"], body={"title": "Тест", "member_ids": [user["id"] for user in users]})[1] + barrier = threading.Barrier(10) + + def send(client_index): + barrier.wait() + for message_index in range(10): + self.request("POST", "/api/v1/chats/%s/messages" % chat["id"], user=users[client_index]["id"], body={"text": "message-%d-%d" % (client_index, message_index)}) + + threads = [threading.Thread(target=send, args=(index,)) for index in range(10)] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + status, page = self.request("GET", "/api/v1/chats/%s/messages?limit=100" % chat["id"], user=users[0]["id"]) + self.assertEqual(status, 200) + self.assertEqual(len(page["items"]), 100) + self.assertEqual(len({message["id"] for message in page["items"]}), 100) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file