Files
mtusi2026lab3/server.py

318 lines
22 KiB
Python

#!/usr/bin/env python3
"""PostgreSQL-backed messenger API for MTUSI lab 2."""
from __future__ import annotations
import base64, binascii, hashlib, json, logging, os, re, secrets, signal, socket, threading, time, uuid
from datetime import datetime, timedelta, timezone
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout
import redis
from argon2 import PasswordHasher, exceptions as argon_exc
LOG = logging.getLogger("messenger")
USERNAME_RE = re.compile(r"\A[a-z0-9_]{3,32}\Z")
POOL: ConnectionPool | None = None
CACHE: redis.Redis | None = None
PASSWORDS = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
MAX_BODY_BYTES = 1024 * 1024
CURSOR_SECRET = os.getenv("CURSOR_SECRET", "local-only-change-this-cursor-secret").encode("utf-8")
INSTANCE_ID = os.getenv("API_INSTANCE_ID") or socket.gethostname() or str(uuid.uuid4())
IDEMPOTENCY_KEY_RE = re.compile(r"\A[A-Za-z0-9._:-]{1,128}\Z")
def utcnow() -> datetime: return datetime.now(timezone.utc)
def stamp(value: datetime) -> str: return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def new_id() -> str: return str(uuid.uuid4())
class ApiError(Exception):
def __init__(self, status, code, message): self.status, self.code, self.message = status, code, message
def invalid(message="Некорректный запрос"): raise ApiError(400, "invalid_request", message)
def unavailable(): raise ApiError(503, "unavailable", "Зависимость временно недоступна")
def db():
assert POOL is not None
return POOL.connection()
def migrate():
migrations = Path(__file__).parent / "migrations"
with db() as conn:
conn.execute("SELECT pg_advisory_xact_lock(2026102802)")
conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())")
for migration in sorted(migrations.glob("*.sql")):
version = migration.stem
if conn.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (version,)).fetchone() is None:
conn.execute(migration.read_text(encoding="utf-8"))
conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (version,))
def as_user(row): return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"], "created_at": stamp(row["created_at"])}
def as_chat(row, members): return {"id": str(row["id"]), "title": row["title"], "member_ids": [str(x) for x in members], "created_at": stamp(row["created_at"])}
def as_message(row): 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 require_text(value, field, maximum):
if not isinstance(value, str) or not value.strip() or len(value) > maximum: invalid(f"Поле {field} должно содержать от 1 до {maximum} символов и не быть пустым")
try: value.encode("utf-8")
except UnicodeEncodeError: invalid(f"Поле {field} должно содержать корректный Unicode")
return value
def strict_object(value, allowed, required):
if not isinstance(value, dict) or set(value)-allowed or required-set(value): invalid("Тело запроса содержит неверные поля")
return value
def parse_uuid(value, label="UUID"):
try: return str(uuid.UUID(value))
except (ValueError, TypeError, AttributeError): invalid(f"Некорректный {label}")
def cursor_encode(scope, row):
obj = {"scope":scope,"created_at":stamp(row["created_at"]),"id":str(row["id"])}
raw = json.dumps(obj,separators=(",",":"),ensure_ascii=True).encode()
sig = hashlib.sha256(CURSOR_SECRET+raw).digest()[:12]
return base64.urlsafe_b64encode(raw+sig).decode().rstrip("=")
def cursor_decode(value, scope):
try:
raw = base64.urlsafe_b64decode(value+"="*(-len(value)%4)); payload,sig=raw[:-12],raw[-12:]
if not secrets.compare_digest(sig,hashlib.sha256(CURSOR_SECRET+payload).digest()[:12]): invalid("Некорректный cursor")
obj=json.loads(payload)
if set(obj)!={"scope","created_at","id"} or obj["scope"]!=scope: invalid("Cursor относится к другому списку")
dt=datetime.fromisoformat(obj["created_at"].replace("Z","+00:00")); return dt,parse_uuid(obj["id"])
except (ValueError,TypeError,KeyError,binascii.Error): invalid("Некорректный cursor")
class Handler(BaseHTTPRequestHandler):
protocol_version="HTTP/1.0"
def setup(self): super().setup(); self.connection.settimeout(3)
def log_message(self, fmt,*args): LOG.info("%s %s %s",self.command,urlsplit(self.path).path,args[1] if len(args)>1 else "")
def do_GET(self): self.dispatch()
def do_POST(self): self.dispatch()
def do_DELETE(self): self.dispatch()
def send_json(self,status,payload,headers=None):
body=json.dumps(payload,ensure_ascii=False,separators=(",",":")).encode()
self.send_response(status); self.send_header("Content-Type","application/json; charset=utf-8"); self.send_header("Content-Length",str(len(body)))
self.send_header("X-Request-Id",self.request_id); self.send_header("X-Instance-Id",INSTANCE_ID)
for k,v in (headers or {}).items(): self.send_header(k,v)
self.end_headers(); self.wfile.write(body)
def empty(self,status,headers=None):
self.send_response(status); self.send_header("Content-Length","0"); self.send_header("X-Request-Id",self.request_id); self.send_header("X-Instance-Id",INSTANCE_ID)
for k,v in (headers or {}).items(): self.send_header(k,v)
self.end_headers()
def error(self,e): self.send_json(e.status,{"error":{"code":e.code,"message":e.message,"request_id":self.request_id}},getattr(e,"headers",None))
def read_json(self):
if self.headers.get_content_type()!="application/json": raise ApiError(415,"unsupported_media_type","Ожидается Content-Type: application/json")
try: n=int(self.headers.get("Content-Length",""))
except ValueError: invalid("Некорректный Content-Length")
if n<0: invalid("Некорректный Content-Length")
if n>MAX_BODY_BYTES: raise ApiError(413,"payload_too_large","Тело запроса слишком велико")
raw=self.rfile.read(n)
if len(raw)!=n: invalid("Тело запроса передано не полностью")
try: val=json.loads(raw.decode("utf-8"))
except (UnicodeError,json.JSONDecodeError): invalid("Тело запроса должно быть корректным JSON UTF-8")
if not isinstance(val,dict): invalid("Тело запроса должно быть JSON-объектом")
return val
def challenge(self,scheme):
e=ApiError(401,"unauthorized","Нет действительной сессии"); e.headers={"WWW-Authenticate":scheme}; raise e
def authenticate(self):
header=self.headers.get("Authorization","")
if not header.startswith("Bearer "): self.challenge('Bearer realm="messenger"')
token=header[7:].strip()
if not token or len(token)>256: self.challenge('Bearer realm="messenger"')
digest=hashlib.sha256(token.encode()).hexdigest(); cache_key="sess:"+digest
uid=None
if CACHE:
try: uid=CACHE.get(cache_key)
except redis.RedisError: pass
with db() as conn:
# Valkey's expiring user ID is a lookup hint. PostgreSQL validates it
# against the live session on every request, so missed cache deletion
# during an outage can never keep a logged-out token valid.
row=None
if uid:
row=conn.execute("SELECT u.id,u.username,u.display_name,u.created_at,s.expires_at FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token_hash=%s AND s.user_id=%s AND s.expires_at>now()",(digest,uid)).fetchone()
if not row:
row=conn.execute("SELECT u.id,u.username,u.display_name,u.created_at,s.expires_at FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token_hash=%s AND s.expires_at>now()",(digest,)).fetchone()
if not row: self.challenge('Bearer realm="messenger"')
if CACHE and str(row["id"])!=uid:
try: CACHE.setex(cache_key,max(1,int((row["expires_at"]-utcnow()).total_seconds())),str(row["id"]))
except redis.RedisError: pass
return as_user(row),digest
def dispatch(self):
self.request_id=secrets.token_hex(16)
try:
split=urlsplit(self.path); path=split.path; q=parse_qs(split.query,keep_blank_values=True)
if path in ("/health/live","/health/ready"):
if self.command!="GET" or q: invalid("Health endpoint принимает только GET без параметров")
if path.endswith("ready"):
try:
with db() as c: c.execute("SELECT 1")
except Exception: unavailable()
self.send_json(200,{"status":"ok"}); return
if path=="/api/v1/users" and self.command=="POST": self.register(); return
if path=="/api/v1/auth/sessions" and self.command=="POST": self.login(); return
if path=="/api/v1/auth/sessions/current" and self.command=="DELETE":
actor,digest=self.authenticate()
with db() as c: c.execute("DELETE FROM sessions WHERE token_hash=%s",(digest,))
if CACHE:
try: CACHE.delete("sess:"+digest)
except redis.RedisError: pass
self.empty(204); return
actor,_=self.authenticate()
if path=="/api/v1/users/me" and self.command=="GET": self.no_query(q); self.send_json(200,actor); return
if path=="/api/v1/chats":
if self.command=="POST": self.no_query(q); self.create_chat(actor); return
if self.command=="GET": self.list_chats(actor,q); return
m=re.fullmatch(r"/api/v1/chats/([^/]+)(?:/(messages))?",path)
if m:
cid=parse_uuid(m.group(1),"chat_id")
if m.group(2)=="messages":
if self.command=="POST": self.create_message(actor,cid); return
if self.command=="GET": self.list_messages(actor,cid,q); return
if self.command=="GET":
self.no_query(q)
with db() as c:
row=c.execute("SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s",(cid,actor["id"])).fetchone()
if not row: raise ApiError(404,"not_found","Объект не найден")
ids=c.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id",(cid,)).fetchall()
self.send_json(200,as_chat(row,[x["user_id"] for x in ids])); return
raise ApiError(404,"not_found","Объект не найден")
except ApiError as e: self.error(e)
except (psycopg.Error,PoolTimeout,redis.RedisError) as e: LOG.warning("dependency error request_id=%s type=%s",self.request_id,type(e).__name__); self.error(ApiError(503,"unavailable","Зависимость временно недоступна"))
except (BrokenPipeError,ConnectionResetError): pass
except Exception: LOG.exception("request failed request_id=%s",self.request_id); self.error(ApiError(500,"internal_error","Внутренняя ошибка сервера"))
def no_query(self,q):
if q: invalid("Этот endpoint не принимает query-параметры")
def register(self):
b=strict_object(self.read_json(),{"username","display_name","password"},{"username","display_name","password"})
if not isinstance(b["username"],str) or not USERNAME_RE.fullmatch(b["username"]): invalid("username должен соответствовать [a-z0-9_]{3,32}")
name=require_text(b["display_name"],"display_name",100); password=b["password"]
if not isinstance(password,str) or not 12<=len(password)<=128: invalid("password должен содержать от 12 до 128 символов")
uid=new_id(); hashed=PASSWORDS.hash(password)
try:
with db() as c: row=c.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING id,username,display_name,created_at",(uid,b["username"],name,hashed)).fetchone()
except psycopg.errors.UniqueViolation: raise ApiError(409,"conflict","username уже занят")
self.send_json(201,as_user(row))
def login(self):
if self.headers.get("Content-Length") not in (None, "0", ""): invalid("POST /auth/sessions не принимает body")
h=self.headers.get("Authorization","")
try:
if not h.startswith("Basic "): raise ValueError()
userpass=base64.b64decode(h[6:],validate=True).decode("utf-8"); username,password=userpass.split(":",1)
except (ValueError,UnicodeError,binascii.Error): self.challenge('Basic realm="messenger", charset="UTF-8"')
with db() as c: row=c.execute("SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=%s",(username,)).fetchone()
# Verify a fixed dummy hash for unknown users to reduce timing-based enumeration.
try: ok=PASSWORDS.verify(row["password_hash"] if row else DUMMY_HASH,password)
except (argon_exc.VerificationError,ValueError): ok=False
if not row or not ok: self.challenge('Basic realm="messenger", charset="UTF-8"')
token=secrets.token_urlsafe(32); digest=hashlib.sha256(token.encode()).hexdigest(); ttl=int(os.getenv("SESSION_TTL_SECONDS","3600")); expires=utcnow()+timedelta(seconds=ttl)
with db() as c: c.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,%s)",(digest,row["id"],expires))
if CACHE:
try: CACHE.setex("sess:"+digest,ttl,str(row["id"]))
except redis.RedisError: pass
self.send_json(201,{"token":token,"token_type":"Bearer","expires_at":stamp(expires),"user":as_user(row)})
def create_chat(self,actor):
b=strict_object(self.read_json(),{"title","member_ids"},{"title","member_ids"}); title=require_text(b["title"],"title",100); ids=b["member_ids"]
if not isinstance(ids,list) or not 1<=len(ids)<=100: invalid("member_ids должен содержать от 1 до 100 UUID")
ids=[parse_uuid(v,"member_id") for v in ids]
if len(set(ids))!=len(ids): invalid("member_ids не должен содержать повторов")
if actor["id"] not in ids: invalid("Создатель чата должен входить в member_ids")
cid=new_id()
try:
with db() as c:
known=c.execute("SELECT id FROM users WHERE id=ANY(%s)",(ids,)).fetchall()
if len(known)!=len(ids): invalid("Все участники чата должны быть зарегистрированы")
row=c.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING id,title,created_at",(cid,title)).fetchone()
with c.cursor() as cursor:
cursor.executemany("INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)",[(cid,u) for u in ids])
except psycopg.errors.ForeignKeyViolation: invalid("Все участники чата должны быть зарегистрированы")
self.send_json(201,as_chat(row,ids))
def parse_page(self,q,scope):
if set(q)-{"limit","cursor"} or any(len(v)!=1 for v in q.values()): invalid("Неверные параметры пагинации")
raw=q.get("limit",["50"])[0]
if not re.fullmatch(r"[0-9]{1,3}",raw): invalid("limit должен быть целым числом от 1 до 100")
limit=int(raw)
if not 1<=limit<=100: invalid("limit должен быть целым числом от 1 до 100")
cur=cursor_decode(q["cursor"][0],scope) if "cursor" in q and q["cursor"][0] else None
if "cursor" in q and not q["cursor"][0]: invalid("cursor не должен быть пустым")
return limit,cur
def list_chats(self,actor,q):
limit,cur=self.parse_page(q,"chats"); params=[actor["id"]]; clause=""
if cur: clause=" AND (c.created_at,c.id)>(%s,%s)"; params.extend(cur)
with db() as c:
rows=c.execute("SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s"+clause+" ORDER BY c.created_at,c.id LIMIT %s",(*params,limit+1)).fetchall()
items=[]
for row in rows[:limit]:
members=c.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id",(row["id"],)).fetchall(); items.append(as_chat(row,[m["user_id"] for m in members]))
self.send_json(200,{"items":items,"next_cursor":cursor_encode("chats",rows[limit-1]) if len(rows)>limit else None})
def create_message(self,actor,cid):
self.no_query(parse_qs(urlsplit(self.path).query,keep_blank_values=True))
key=self.headers.get("Idempotency-Key", "")
if not IDEMPOTENCY_KEY_RE.fullmatch(key): invalid("Idempotency-Key обязателен и должен соответствовать [A-Za-z0-9._:-]{1,128}")
with db() as c:
if not c.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",(cid,actor["id"])).fetchone(): raise ApiError(404,"not_found","Объект не найден")
b=strict_object(self.read_json(),{"text","attachment_ids"},{"text"}); text=require_text(b["text"],"text",4000)
attachment_ids=b.get("attachment_ids", [])
if attachment_ids != []: invalid("Вложения не поддерживаются в лабораторной 3")
canonical=json.dumps({"text":text,"attachment_ids":[]},ensure_ascii=False,sort_keys=True,separators=(",",":"))
request_hash=hashlib.sha256(canonical.encode("utf-8")).hexdigest()
resource_path=f"/api/v1/chats/{cid}/messages"
scope=f"{actor['id']}\nPOST\n{resource_path}\n{key}"
try:
with db() as c:
# One transaction-scoped lock serializes equal keys across API replicas.
c.execute("SELECT pg_advisory_xact_lock(hashtextextended(%s,0))",(scope,))
old=c.execute("SELECT request_hash,response_body FROM idempotency_keys WHERE user_id=%s AND method='POST' AND resource_path=%s AND key=%s AND created_at>now()-interval '24 hours'",(actor["id"],resource_path,key)).fetchone()
if old:
if old["request_hash"]!=request_hash: raise ApiError(409,"conflict","Idempotency-Key уже использован с другим содержимым")
payload=old["response_body"]
else:
c.execute("DELETE FROM idempotency_keys WHERE user_id=%s AND method='POST' AND resource_path=%s AND key=%s",(actor["id"],resource_path,key))
row=c.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING id,chat_id,sender_id,text,created_at",(new_id(),cid,actor["id"],text)).fetchone()
payload=as_message(row)
c.execute("INSERT INTO idempotency_keys(user_id,method,resource_path,key,request_hash,response_body) VALUES (%s,'POST',%s,%s,%s,%s::jsonb)",(actor["id"],resource_path,key,request_hash,json.dumps(payload,ensure_ascii=False,separators=(",",":"))))
except psycopg.errors.ForeignKeyViolation: raise ApiError(404,"not_found","Объект не найден")
self.send_json(201,payload)
def list_messages(self,actor,cid,q):
with db() as c:
if not c.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",(cid,actor["id"])).fetchone(): raise ApiError(404,"not_found","Объект не найден")
limit,cur=self.parse_page(q,"messages:"+cid); params=[cid]; clause=""
if cur: clause=" AND (created_at,id)>(%s,%s)"; params.extend(cur)
with db() as c: rows=c.execute("SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s"+clause+" ORDER BY created_at,id LIMIT %s",(*params,limit+1)).fetchall()
self.send_json(200,{"items":[as_message(r) for r in rows[:limit]],"next_cursor":cursor_encode("messages:"+cid,rows[limit-1]) if len(rows)>limit else None})
class Server(ThreadingHTTPServer):
daemon_threads=True; allow_reuse_address=True
def main():
global POOL,CACHE,DUMMY_HASH
logging.basicConfig(level=os.getenv("LOG_LEVEL","INFO").upper(),format="%(asctime)s %(levelname)s %(message)s")
pool_max=int(os.getenv("DB_POOL_MAX","10"))
if not 1<=pool_max<=50: raise SystemExit("DB_POOL_MAX must be between 1 and 50")
POOL=ConnectionPool(os.getenv("DATABASE_URL","postgresql://messenger:messenger@postgres:5432/messenger"),min_size=int(os.getenv("DB_POOL_MIN","1")),max_size=pool_max,timeout=3,kwargs={"row_factory":dict_row},open=True)
CACHE=redis.Redis.from_url(os.getenv("CACHE_URL","redis://valkey:6379/0"),socket_connect_timeout=0.5,socket_timeout=0.5,decode_responses=True)
DUMMY_HASH=PASSWORDS.hash("dummy-password-do-not-use-123")
deadline=time.monotonic()+60
while True:
try: migrate(); break
except (psycopg.Error, PoolTimeout):
if time.monotonic()>deadline: raise
LOG.info("waiting for PostgreSQL"); time.sleep(1)
if os.getenv("RUN_MIGRATIONS_ONLY") == "1":
POOL.close()
return
try: CACHE.ping()
except redis.RedisError: LOG.warning("Valkey unavailable; session validation will use PostgreSQL")
host=os.getenv("APP_HOST","0.0.0.0"); port=int(os.getenv("APP_PORT","8080")); server=Server((host,port),Handler)
def stop(signum,_frame): LOG.info("received signal %s; stopping",signum); threading.Thread(target=server.shutdown,daemon=True).start()
signal.signal(signal.SIGTERM,stop); signal.signal(signal.SIGINT,stop)
try: LOG.info("server listening on %s:%s",host,port); server.serve_forever(poll_interval=.2)
finally: server.server_close(); POOL.close(); LOG.info("server stopped")
if __name__=="__main__": main()