#!/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, tempfile, 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, quote, 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 import boto3 from botocore.config import Config from botocore.exceptions import BotoCoreError, ClientError from PIL import Image, UnidentifiedImageError 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 S3 = 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") MAX_UPLOAD_BYTES = int(os.getenv("MAX_UPLOAD_BYTES", "10485760")) MAX_IMAGE_PIXELS = int(os.getenv("MAX_IMAGE_PIXELS", "40000000")) BUCKET = os.getenv("S3_BUCKET", "messenger-attachments") UPLOAD_SLOTS = threading.BoundedSemaphore(max(1,int(os.getenv("UPLOAD_CONCURRENCY", "2")))) 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"]), "attachment_ids": [str(x) for x in row.get("attachment_ids", [])]} def message_payload(conn, row): ids=conn.execute("SELECT attachment_id FROM message_attachments WHERE message_id=%s ORDER BY attachment_id",(row["id"],)).fetchall() return as_message({**row,"attachment_ids":[x["attachment_id"] for x in ids]}) 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("Файл должен содержать данные") 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") S3.list_objects_v2(Bucket=BUCKET,Prefix="attachments/",MaxKeys=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|attachments))?",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 m.group(2)=="attachments" and self.command=="POST": self.upload_attachment(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 m=re.fullmatch(r"/api/v1/attachments/([^/]+)(?:/(content))?",path) if m: aid=parse_uuid(m.group(1),"attachment_id") if m.group(2)=="content" and self.command=="GET": self.download_attachment(actor,aid,q); return if m.group(2) is None and self.command=="GET": self.get_attachment(actor,aid,q); return raise ApiError(404,"not_found","Объект не найден") except ApiError as e: self.error(e) except (psycopg.Error,PoolTimeout,redis.RedisError,BotoCoreError,ClientError) 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 upload_attachment(self,actor,cid,q): if set(q)!={"filename"} or len(q["filename"])!=1: invalid("Требуется один query-параметр filename") filename=q["filename"][0] if not isinstance(filename,str) or not 1<=len(filename)<=255 or any(ord(ch)<32 or ord(ch)==127 for ch in filename) or "/" in filename or "\\" in filename or "\x00" in filename: invalid("filename должен быть безопасным отображаемым именем") if self.headers.get_content_type() not in ("image/png","image/jpeg"): raise ApiError(415,"unsupported_media_type","Поддерживаются только PNG и JPEG") try: n=int(self.headers.get("Content-Length","")) except ValueError: invalid("Некорректный Content-Length") if n<0: invalid("Некорректный Content-Length") if n>MAX_UPLOAD_BYTES: raise ApiError(413,"payload_too_large","Файл превышает 10 MiB") 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","Объект не найден") if not UPLOAD_SLOTS.acquire(timeout=10): raise ApiError(503,"unavailable","Слишком много одновременных загрузок") content_type=self.headers.get_content_type(); expected={"image/png":"PNG","image/jpeg":"JPEG"}[content_type] try: digest_state=hashlib.sha256() with tempfile.SpooledTemporaryFile(max_size=1024*1024,mode="w+b") as data: remaining=n while remaining: chunk=self.rfile.read(min(64*1024,remaining)) if not chunk: invalid("Файл передан не полностью") data.write(chunk); digest_state.update(chunk); remaining-=len(chunk) digest=digest_state.hexdigest() try: data.seek(0) with Image.open(data) as image: if image.format!=expected: raise ApiError(415,"unsupported_media_type","Content-Type не соответствует изображению") width,height=image.size if width*height>MAX_IMAGE_PIXELS: raise ApiError(413,"payload_too_large","Изображение превышает 40 млн пикселей") image.verify() data.seek(0) with Image.open(data) as image: image.load() except ApiError: raise except (UnidentifiedImageError,OSError,ValueError,Image.DecompressionBombError): raise ApiError(415,"unsupported_media_type","Изображение повреждено или не поддерживается") aid=new_id(); key=f"attachments/{aid}" data.seek(0) S3.put_object(Bucket=BUCKET,Key=key,Body=data,ContentType=content_type,Metadata={"sha256":digest,"attachment-id":aid}) try: with db() as c: row=c.execute("INSERT INTO attachments(id,chat_id,owner_id,object_key,filename,content_type,size_bytes,sha256,status) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,'ready') RETURNING *",(aid,cid,actor["id"],key,filename,content_type,n,digest)).fetchone() except Exception: try: S3.delete_object(Bucket=BUCKET,Key=key) except Exception: LOG.exception("S3 compensation failed for attachment %s",aid) raise except (psycopg.Error,PoolTimeout): raise finally: UPLOAD_SLOTS.release() self.send_json(201,self.attachment_json(row)) def attachment_json(self,row): if row["status"]!="ready": raise ApiError(409,"conflict","Вложение недоступно") return {"id":str(row["id"]),"chat_id":str(row["chat_id"]),"owner_id":str(row["owner_id"]),"filename":row["filename"],"content_type":row["content_type"],"size_bytes":row["size_bytes"],"sha256":row["sha256"],"status":"ready","variants":[],"error_code":None,"created_at":stamp(row["created_at"]),"updated_at":stamp(row["updated_at"])} def authorized_attachment(self,actor,aid): with db() as c: row=c.execute("SELECT a.* FROM attachments a JOIN chat_members m ON m.chat_id=a.chat_id WHERE a.id=%s AND m.user_id=%s",(aid,actor["id"])).fetchone() if not row: raise ApiError(404,"not_found","Объект не найден") return row def get_attachment(self,actor,aid,q): self.no_query(q); row=self.authorized_attachment(actor,aid); self.send_json(200,self.attachment_json(row)) def download_attachment(self,actor,aid,q): if set(q)-{"variant"} or len(q.get("variant",["original"]))!=1: invalid("Недопустимые параметры") if q.get("variant",["original"])[0]!="original": raise ApiError(404,"not_found","Вариант не найден") row=self.authorized_attachment(actor,aid) if row["status"]!="ready": raise ApiError(409,"conflict","Вложение недоступно") obj=S3.get_object(Bucket=BUCKET,Key=row["object_key"]); data=obj["Body"].read(MAX_UPLOAD_BYTES+1) if len(data)>MAX_UPLOAD_BYTES: unavailable() headers={"Content-Type":row["content_type"],"Content-Length":str(len(data)),"Content-Disposition":"attachment; filename*=UTF-8''"+quote(row["filename"].encode("utf-8"),safe=""),'X-Content-SHA256':row["sha256"]} self.send_response(200) for k,v in headers.items(): self.send_header(k,v) self.send_header("X-Request-Id",self.request_id); self.send_header("X-Instance-Id",INSTANCE_ID); self.end_headers(); self.wfile.write(data) 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=b["text"] attachment_ids=b.get("attachment_ids", []) if not isinstance(text,str) or len(text)>4000: invalid("text должен содержать не более 4000 символов") if not isinstance(attachment_ids,list) or len(attachment_ids)>10: invalid("attachment_ids должен содержать от 0 до 10 ID") attachment_ids=[parse_uuid(v,"attachment_id") for v in attachment_ids] if len(set(attachment_ids))!=len(attachment_ids): invalid("attachment_ids не должен содержать повторов") if not text.strip() and not attachment_ids: invalid("Сообщение должно содержать текст или вложение") if text.strip(): require_text(text,"text",4000) attachment_ids=sorted(attachment_ids) canonical=json.dumps({"text":text,"attachment_ids":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)) if attachment_ids: allowed=c.execute("SELECT id,status FROM attachments WHERE id=ANY(%s) AND chat_id=%s",(attachment_ids,cid)).fetchall() if len(allowed)!=len(attachment_ids): raise ApiError(404,"not_found","Вложение не найдено") if any(a["status"]!="ready" for a in allowed): raise ApiError(409,"conflict","Вложение недоступно") 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() if attachment_ids: with c.cursor() as cur: cur.executemany("INSERT INTO message_attachments(message_id,attachment_id,chat_id) VALUES (%s,%s,%s)",[(row["id"],aid,cid) for aid in attachment_ids]) payload=message_payload(c,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() with db() as c: items=[message_payload(c,r) for r in rows[:limit]] self.send_json(200,{"items":items,"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,S3 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) S3=boto3.client("s3",endpoint_url=os.getenv("S3_ENDPOINT","http://s3:9000"),region_name=os.getenv("S3_REGION","us-east-1"),aws_access_key_id=os.getenv("S3_ACCESS_KEY_ID","messenger-api"),aws_secret_access_key=os.getenv("S3_SECRET_ACCESS_KEY","local-only-change-this-secret"),config=Config(connect_timeout=2,read_timeout=10,retries={"max_attempts":1},s3={"addressing_style":"path"})) 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()