Files
mtusi2026lab2/server.py

452 lines
20 KiB
Python

#!/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()