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