293 lines
20 KiB
Python
293 lines
20 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, 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 = secrets.token_bytes(32)
|
|
INSTANCE_ID = str(uuid.uuid4())
|
|
|
|
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():
|
|
migration = Path(__file__).parent / "migrations" / "001_initial.sql"
|
|
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())")
|
|
if conn.execute("SELECT 1 FROM schema_migrations WHERE version='001_initial'").fetchone() is None:
|
|
conn.execute(migration.read_text(encoding="utf-8"))
|
|
conn.execute("INSERT INTO schema_migrations(version) VALUES ('001_initial')")
|
|
|
|
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))
|
|
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"},{"text"}); text=require_text(b["text"],"text",4000); mid=new_id()
|
|
try:
|
|
with db() as c: 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",(mid,cid,actor["id"],text)).fetchone()
|
|
except psycopg.errors.ForeignKeyViolation: raise ApiError(404,"not_found","Объект не найден")
|
|
self.send_json(201,as_message(row))
|
|
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=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)
|
|
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()
|