Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
342e016e36 | ||
|
|
8232404176 |
+6
-2
@@ -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
|
||||
@@ -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
|
||||
|
||||
+15
@@ -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"]
|
||||
@@ -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)
|
||||
@@ -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 |
|
||||
|
||||
|
||||
@@ -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()
|
||||
@@ -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:
|
||||
@@ -0,0 +1 @@
|
||||
"""In-memory messenger application."""
|
||||
@@ -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
|
||||
@@ -0,0 +1,5 @@
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status, code, message):
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
@@ -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
|
||||
@@ -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}
|
||||
@@ -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()
|
||||
@@ -0,0 +1 @@
|
||||
psycopg[binary]==3.2.3
|
||||
@@ -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%
|
||||
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
docker compose up -d --build --no-recreate postgres
|
||||
docker compose up -d --build api
|
||||
@@ -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()
|
||||
+1
-1
@@ -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
|
||||
```
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user