Files
mtusi2026lab3/server.py

453 lines
22 KiB
Python

#!/usr/bin/env python3
"""MTUSI lab3: the lab2 messenger API with shared PostgreSQL state.
No user, session, chat, message, or idempotency state is stored in API memory.
Two independent copies of this process may serve the same HTTP endpoint.
"""
from __future__ import annotations
import base64
from datetime import datetime, timedelta, timezone
import hashlib
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import logging
import os
import re
import secrets
import signal
import threading
from urllib.parse import parse_qs, urlsplit
import uuid
import psycopg
from psycopg.rows import dict_row
USER_RE = re.compile(r"[a-z0-9_]{3,32}\Z")
IDEMPOTENCY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}\Z")
MAX_BODY = 1_048_576
INSTANCE_ID = os.environ.get("INSTANCE_ID") or uuid.uuid4().hex
TTL = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
if TTL <= 0:
raise SystemExit("SESSION_TTL_SECONDS must be positive")
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, challenge: str | None = None):
super().__init__(message)
self.status, self.code, self.message, self.challenge = status, code, message, challenge
def db_connect():
"""A short-lived DB connection; transaction rolls back on exceptions."""
return psycopg.connect(
host=os.environ.get("PGHOST", "db"),
port=int(os.environ.get("PGPORT", "5432")),
dbname=os.environ.get("PGDATABASE", "lab3"),
user=os.environ.get("PGUSER", "labuser"),
password=os.environ.get("PGPASSWORD", ""),
connect_timeout=3,
row_factory=dict_row,
options="-c statement_timeout=5000",
)
def stamp(value: datetime) -> str:
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def password_hash(password: str) -> str:
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$" + salt.hex() + "$" + digest.hex()
def password_matches(password: str, encoded: str) -> bool:
try:
method, n, r, p, salt_hex, hash_hex = encoded.split("$")
if method != "scrypt":
return False
digest = hashlib.scrypt(password.encode("utf-8"), salt=bytes.fromhex(salt_hex),
n=int(n), r=int(r), p=int(p))
return secrets.compare_digest(digest, bytes.fromhex(hash_hex))
except (ValueError, TypeError, MemoryError):
return False
def uuid_string(value: object) -> str:
if not isinstance(value, str):
raise ApiError(400, "invalid_request", "Некорректный UUID")
try:
parsed = uuid.UUID(value)
except (ValueError, AttributeError):
raise ApiError(400, "invalid_request", "Некорректный UUID") from None
if str(parsed) != value:
raise ApiError(400, "invalid_request", "Некорректный UUID")
return value
def require_fields(obj: dict, fields: set[str]) -> None:
if set(obj) != fields:
raise ApiError(400, "invalid_request", "Неверный набор полей")
def public_user(row: dict) -> dict:
return {"id": str(row["id"]), "username": row["username"],
"display_name": row["display_name"], "created_at": stamp(row["created_at"])}
def public_message(row: dict) -> dict:
return {"id": str(row["id"]), "chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]), "text": row["text"],
"created_at": stamp(row["created_at"])}
def fetch_chat(conn, chat_id: str) -> dict | None:
row = conn.execute(
"""SELECT c.id, c.title, c.created_at,
array_agg(cm.user_id ORDER BY cm.member_index) AS member_ids
FROM chats c JOIN chat_members cm ON cm.chat_id = c.id
WHERE c.id = %s GROUP BY c.id""", (chat_id,)).fetchone()
if row is None:
return None
return {"id": str(row["id"]), "title": row["title"],
"member_ids": [str(x) for x in row["member_ids"]],
"created_at": stamp(row["created_at"])}
def pagination(query: dict[str, list[str]], scope: str):
if set(query) - {"limit", "cursor"} or any(len(v) != 1 for v in query.values()):
raise ApiError(400, "invalid_request", "Некорректные параметры страницы")
raw = query.get("limit", ["50"])[0]
if not re.fullmatch(r"[0-9]+", raw or "") or not 1 <= int(raw) <= 100:
raise ApiError(400, "invalid_request", "limit должен быть от 1 до 100")
limit = int(raw)
cursor = query.get("cursor", [None])[0]
position = None
if cursor is not None:
try:
decoded = base64.b64decode(cursor + "=" * (-len(cursor) % 4),
altchars=b"-_", validate=True)
packed = json.loads(decoded)
if (not isinstance(packed, list) or len(packed) != 3 or
packed[0] != scope or not isinstance(packed[1], str)):
raise ValueError
created = datetime.fromisoformat(packed[1].replace("Z", "+00:00"))
item_id = uuid_string(packed[2])
if created.tzinfo is None:
raise ValueError
position = (created, item_id)
except (ValueError, UnicodeError, json.JSONDecodeError, ApiError):
raise ApiError(400, "invalid_request", "Некорректный cursor") from None
return limit, position
def next_page(items: list[dict], limit: int, scope: str) -> dict:
has_more = len(items) > limit
selected = items[:limit]
cursor = None
if has_more:
last = selected[-1]
payload = json.dumps([scope, last["created_at"], last["id"]], separators=(",", ":"))
cursor = base64.urlsafe_b64encode(payload.encode()).decode().rstrip("=")
return {"items": selected, "next_cursor": cursor}
class Handler(BaseHTTPRequestHandler):
server_version = "MTUSI-Lab3/1.0"
sys_version = ""
def log_message(self, fmt: str, *args) -> None:
logging.info("%s %s %s", self.address_string(), self.command, urlsplit(self.path).path)
def send_json(self, status: int, payload: dict | None, request_id: str, challenge: str | None = None):
data = (json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
if payload is not None else b"")
self.send_response(status)
self.send_header("X-Request-Id", request_id)
self.send_header("X-Instance-Id", INSTANCE_ID)
if payload is not None:
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(data)))
if challenge:
self.send_header("WWW-Authenticate", challenge)
self.end_headers()
if data:
self.wfile.write(data)
def read_json(self) -> dict:
if self.headers.get("Content-Type", "").split(";", 1)[0].lower().strip() != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
try:
length = int(self.headers.get("Content-Length", "0"))
except ValueError:
raise ApiError(400, "invalid_request", "Некорректный Content-Length") from None
if length < 0 or length > MAX_BODY:
raise ApiError(413, "payload_too_large", "Слишком большое тело запроса")
try:
data = json.loads(self.rfile.read(length).decode("utf-8"))
except (ValueError, UnicodeError):
raise ApiError(400, "invalid_request", "Некорректный JSON") from None
if not isinstance(data, dict):
raise ApiError(400, "invalid_request", "JSON должен быть объектом")
return data
def basic_credentials(self):
auth = self.headers.get("Authorization", "")
scheme, sep, value = auth.partition(" ")
fail = ApiError(401, "unauthorized", "Неверные credentials",
'Basic realm="messenger", charset="UTF-8"')
if not sep or scheme.lower() != "basic":
raise fail
try:
decoded = base64.b64decode(value, validate=True).decode("utf-8")
except (ValueError, UnicodeError):
raise fail from None
if ":" not in decoded:
raise fail
username, password = decoded.split(":", 1)
if not username or not password:
raise fail
return username, password
def bearer_user(self, conn) -> tuple[dict, str]:
auth = self.headers.get("Authorization", "")
scheme, sep, token = auth.partition(" ")
fail = ApiError(401, "unauthorized", "Требуется действительная Bearer-сессия",
'Bearer realm="messenger"')
if not sep or scheme.lower() != "bearer" or not token or len(token) > 512:
raise fail
token_hash = hashlib.sha256(token.encode()).hexdigest()
row = conn.execute(
"""SELECT u.id, u.username, u.display_name, u.created_at
FROM sessions s JOIN users u ON u.id=s.user_id
WHERE s.token_hash=%s AND s.expires_at > clock_timestamp()""",
(token_hash,)).fetchone()
if row is None:
raise fail
return row, token_hash
def dispatch(self, rid: str):
parsed = urlsplit(self.path)
path, query = parsed.path, parse_qs(parsed.query, keep_blank_values=True)
if self.command == "GET" and path == "/health/live":
return self.send_json(200, {"status": "ok"}, rid)
if self.command == "GET" and path == "/health/ready":
with db_connect() as conn:
conn.execute("SELECT 1").fetchone()
return self.send_json(200, {"status": "ok"}, rid)
if self.command == "POST" and path == "/api/v1/users":
body = self.read_json()
require_fields(body, {"username", "display_name", "password"})
username, display, password = body["username"], body["display_name"], body["password"]
if not isinstance(username, str) or not USER_RE.fullmatch(username):
raise ApiError(400, "invalid_request", "Некорректный username")
if not isinstance(display, str) or not 1 <= len(display) <= 100 or not display.strip():
raise ApiError(400, "invalid_request", "Некорректный display_name")
if not isinstance(password, str) or not 12 <= len(password) <= 128:
raise ApiError(400, "invalid_request", "Некорректный password")
# Unique constraint in PostgreSQL also handles concurrent registrations.
with db_connect() as conn:
exists = conn.execute("SELECT 1 FROM users WHERE username=%s", (username,)).fetchone()
if exists:
raise ApiError(409, "conflict", "Имя пользователя уже занято")
row = conn.execute(
"""INSERT INTO users(id,username,display_name,password_hash)
VALUES (%s,%s,%s,%s)
RETURNING id,username,display_name,created_at""",
(str(uuid.uuid4()), username, display, password_hash(password))).fetchone()
return self.send_json(201, public_user(row), rid)
if self.command == "POST" and path == "/api/v1/auth/sessions":
username, password = self.basic_credentials()
with db_connect() as conn:
row = conn.execute("SELECT * FROM users WHERE username=%s", (username,)).fetchone()
if row is None or not password_matches(password, row["password_hash"]):
raise ApiError(401, "unauthorized", "Неверные credentials",
'Basic realm="messenger", charset="UTF-8"')
token = secrets.token_urlsafe(32)
expiry = datetime.now(timezone.utc) + timedelta(seconds=TTL)
conn.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES(%s,%s,%s)",
(hashlib.sha256(token.encode()).hexdigest(), row["id"], expiry))
return self.send_json(201, {"token": token, "token_type": "Bearer",
"expires_at": stamp(expiry), "user": public_user(row)}, rid)
with db_connect() as conn:
actor, token_hash = self.bearer_user(conn)
user_id = str(actor["id"])
if self.command == "GET" and path == "/api/v1/users/me":
result = public_user(actor)
status = 200
elif self.command == "DELETE" and path == "/api/v1/auth/sessions/current":
conn.execute("DELETE FROM sessions WHERE token_hash=%s", (token_hash,))
result, status = None, 204
elif self.command == "POST" and path == "/api/v1/chats":
body = self.read_json()
require_fields(body, {"title", "member_ids"})
title, members = body["title"], body["member_ids"]
if not isinstance(title, str) or not 1 <= len(title) <= 100 or not title.strip():
raise ApiError(400, "invalid_request", "Некорректный title")
if not isinstance(members, list) or not 1 <= len(members) <= 100:
raise ApiError(400, "invalid_request", "Некорректный список участников")
members = [uuid_string(x) for x in members]
if len(set(members)) != len(members) or user_id not in members:
raise ApiError(400, "invalid_request", "Участники должны быть уникальны, включая автора")
existing = conn.execute("SELECT id FROM users WHERE id = ANY(%s)",
([uuid.UUID(x) for x in members],)).fetchall()
if len(existing) != len(members):
raise ApiError(400, "invalid_request", "Неизвестный участник")
chat_id = str(uuid.uuid4())
conn.execute("INSERT INTO chats(id,title) VALUES(%s,%s)", (chat_id, title))
for position, member_id in enumerate(members):
conn.execute("INSERT INTO chat_members(chat_id,user_id,member_index) VALUES(%s,%s,%s)",
(chat_id, member_id, position))
result, status = fetch_chat(conn, chat_id), 201
elif self.command == "GET" and path == "/api/v1/chats":
scope = "chats:" + user_id
limit, position = pagination(query, scope)
if position:
rows = conn.execute(
"""SELECT c.id FROM chats c JOIN chat_members m ON m.chat_id=c.id
WHERE m.user_id=%s AND (c.created_at,c.id)>(%s,%s)
ORDER BY c.created_at,c.id LIMIT %s""",
(user_id, *position, limit + 1)).fetchall()
else:
rows = conn.execute(
"""SELECT c.id FROM chats c JOIN chat_members m ON m.chat_id=c.id
WHERE m.user_id=%s ORDER BY c.created_at,c.id LIMIT %s""",
(user_id, limit + 1)).fetchall()
result = next_page([fetch_chat(conn, str(x["id"])) for x in rows], limit, scope)
status = 200
else:
match = re.fullmatch(r"/api/v1/chats/([^/]+)(?:/(messages))?", path)
if not match or self.command not in {"GET", "POST"}:
raise ApiError(404, "not_found", "Объект не найден")
chat_id = uuid_string(match.group(1))
member = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",
(chat_id, user_id)).fetchone()
if not member:
raise ApiError(404, "not_found", "Объект не найден")
section = match.group(2)
if self.command == "GET" and section is None:
result, status = fetch_chat(conn, chat_id), 200
elif self.command == "GET" and section == "messages":
scope = "messages:" + chat_id
limit, position = pagination(query, scope)
if position:
rows = conn.execute(
"""SELECT id,chat_id,sender_id,text,created_at FROM messages
WHERE chat_id=%s AND (created_at,id)>(%s,%s)
ORDER BY created_at,id LIMIT %s""",
(chat_id, *position, limit + 1)).fetchall()
else:
rows = conn.execute(
"""SELECT id,chat_id,sender_id,text,created_at FROM messages
WHERE chat_id=%s ORDER BY created_at,id LIMIT %s""",
(chat_id, limit + 1)).fetchall()
result, status = next_page([public_message(x) for x in rows], limit, scope), 200
elif self.command == "POST" and section == "messages":
key = self.headers.get("Idempotency-Key", "")
if not IDEMPOTENCY_RE.fullmatch(key):
raise ApiError(400, "invalid_request", "Требуется Idempotency-Key")
body = self.read_json()
require_fields(body, {"text"})
value = body["text"]
if not isinstance(value, str) or not 1 <= len(value) <= 4000 or not value.strip():
raise ApiError(400, "invalid_request", "Текст сообщения должен быть от 1 до 4000 символов")
digest = hashlib.sha256(json.dumps({"text": value}, sort_keys=True,
ensure_ascii=False, separators=(",", ":")).encode()).hexdigest()
# Transaction-level PG lock serializes two replicas using the same key.
# The message and its deduplication record commit together.
lock_key = user_id + ":POST:/api/v1/chats/" + chat_id + "/messages:" + key
conn.execute("SELECT pg_advisory_xact_lock(hashtext(%s))", (lock_key,))
old = conn.execute(
"""SELECT i.body_hash,m.id,m.chat_id,m.sender_id,m.text,m.created_at
FROM message_idempotency i JOIN messages m ON i.message_id=m.id
WHERE i.user_id=%s AND i.chat_id=%s AND i.idem_key=%s""",
(user_id, chat_id, key)).fetchone()
if old:
if old["body_hash"] != digest:
raise ApiError(409, "conflict", "Idempotency-Key уже использован для другого текста")
result = public_message(old)
else:
row = conn.execute(
"""INSERT INTO messages(id,chat_id,sender_id,text)
VALUES(%s,%s,%s,%s)
RETURNING id,chat_id,sender_id,text,created_at""",
(str(uuid.uuid4()), chat_id, user_id, value)).fetchone()
conn.execute(
"""INSERT INTO message_idempotency(user_id,chat_id,idem_key,body_hash,message_id)
VALUES(%s,%s,%s,%s,%s)""",
(user_id, chat_id, key, digest, row["id"]))
result = public_message(row)
status = 201
else:
raise ApiError(404, "not_found", "Объект не найден")
self.send_json(status, result, rid)
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):
rid = uuid.uuid4().hex
try:
self.dispatch(rid)
except ApiError as exc:
self.safe_json_error(exc, rid)
except psycopg.errors.UniqueViolation:
self.safe_json_error(ApiError(409, "conflict", "Объект уже существует"), rid)
except (psycopg.OperationalError, psycopg.errors.QueryCanceled) as exc:
logging.warning("Database unavailable: %s", type(exc).__name__)
self.safe_json_error(ApiError(503, "unavailable", "База данных недоступна"), rid)
except (BrokenPipeError, ConnectionResetError):
pass
except Exception:
logging.exception("Unexpected error (request_id=%s)", rid)
self.safe_json_error(ApiError(500, "internal_error", "Внутренняя ошибка сервера"), rid)
def safe_json_error(self, exc: ApiError, rid: str):
try:
self.send_json(exc.status,
{"error": {"code": exc.code, "message": exc.message, "request_id": rid}},
rid, exc.challenge)
except (BrokenPipeError, ConnectionResetError):
pass
class Server(ThreadingHTTPServer):
daemon_threads = True
allow_reuse_address = True
def main():
logging.basicConfig(level=logging.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"))
server = Server((host, port), Handler)
closing = threading.Event()
def stop(_signal, _frame):
if not closing.is_set():
closing.set()
threading.Thread(target=server.shutdown, daemon=True).start()
signal.signal(signal.SIGTERM, stop)
signal.signal(signal.SIGINT, stop)
logging.info("API instance %s listening on %s:%s", INSTANCE_ID, host, port)
try:
server.serve_forever(poll_interval=0.1)
finally:
server.server_close()
if __name__ == "__main__":
main()