forked from mtusi2026/mtusi2026lab3
453 lines
22 KiB
Python
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()
|