Files
mtusi2026lab4/server.py
T

1004 lines
40 KiB
Python

import base64
import datetime as dt
import hashlib
import json
import logging
import os
import re
import secrets
import signal
import threading
import uuid
import sys
import io
import mimetypes
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlsplit, quote
import psycopg
from psycopg import rows
from psycopg.errors import UniqueViolation
from psycopg_pool import ConnectionPool, PoolTimeout
import redis
import boto3
from botocore.config import Config
from botocore.exceptions import BotoCoreError, ClientError
from PIL import Image, UnidentifiedImageError
from argon2 import PasswordHasher, exceptions as argon2_exceptions
from argon2.low_level import Type
HOST = os.getenv("APP_HOST", "0.0.0.0")
PORT = int(os.getenv("APP_PORT", "8080"))
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
DATABASE_URL_FILE = os.getenv("DATABASE_URL_FILE", "/run/secrets/database_url")
REDIS_URL_FILE = os.getenv("REDIS_URL_FILE", "/run/secrets/redis_url")
MAX_BODY_SIZE = 16 * 1024 * 1024
MAX_UPLOAD_BYTES = int(os.getenv("MAX_UPLOAD_BYTES", "10485760"))
MAX_IMAGE_PIXELS = int(os.getenv("MAX_IMAGE_PIXELS", "40000000"))
S3_ENDPOINT = os.getenv("S3_ENDPOINT", "http://minio:9000")
S3_BUCKET = os.getenv("S3_BUCKET", "messenger-attachments")
S3_ACCESS_KEY_FILE = os.getenv("S3_ACCESS_KEY_ID_FILE", "/run/secrets/s3_access_key_id")
S3_SECRET_KEY_FILE = os.getenv("S3_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_secret_access_key")
s3_client = None
logging.basicConfig(level=os.getenv("LOG_LEVEL", "INFO"), format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger("messenger")
pool = None
redis_client = None
password_hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1, hash_len=32, salt_len=16, type=Type.ID)
shutting_down = False
server = None
def read_secret(path):
return Path(path).read_text(encoding="utf-8").strip()
def now_utc():
return dt.datetime.now(dt.timezone.utc)
def format_time(value):
if value.tzinfo is None:
value = value.replace(tzinfo=dt.timezone.utc)
return value.astimezone(dt.timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def new_id():
return str(uuid.uuid4())
def error_body(code, message, request_id):
return {"error": {"code": code, "message": message, "request_id": request_id}}
def json_bytes(value):
return json.dumps(value, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
def valid_username(value):
return isinstance(value, str) and re.fullmatch(r"[a-z0-9_]{3,32}", value) is not None
def valid_nonblank_string(value, maximum):
return isinstance(value, str) and 1 <= len(value) <= maximum and bool(value.strip())
def valid_uuid(value):
try:
uuid.UUID(value)
return True
except (ValueError, AttributeError, TypeError):
return False
def parse_json_object(raw):
try:
value = json.loads(raw.decode("utf-8"))
except (UnicodeDecodeError, json.JSONDecodeError):
raise ValueError
if not isinstance(value, dict):
raise ValueError
return value
def encode_cursor(scope, created_at, object_id):
payload = json.dumps(
{"scope": scope, "created_at": format_time(created_at), "id": str(object_id)},
separators=(",", ":"),
ensure_ascii=False,
).encode("utf-8")
return base64.urlsafe_b64encode(payload).decode("ascii").rstrip("=")
def decode_cursor(cursor):
try:
raw = cursor.encode("ascii")
raw += b"=" * (-len(raw) % 4)
value = json.loads(base64.urlsafe_b64decode(raw).decode("utf-8"))
if not isinstance(value, dict):
raise ValueError
if not all(isinstance(value.get(key), str) and value[key] for key in ("scope", "created_at", "id")):
raise ValueError
object_id = uuid.UUID(value["id"])
created_at = dt.datetime.fromisoformat(value["created_at"].replace("Z", "+00:00"))
if created_at.tzinfo is None:
raise ValueError
return value["scope"], created_at, str(object_id)
except (ValueError, UnicodeError, json.JSONDecodeError, KeyError, TypeError):
raise ValueError
def validate_keys(value, required):
return set(value) == set(required)
def apply_migrations():
migration_dir = Path(__file__).resolve().parent / "migrations"
with pool.connection() as conn:
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations (version TEXT PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT now())"
)
conn.execute("SELECT pg_advisory_xact_lock(%s)", (7202026,))
for migration in sorted(migration_dir.glob("*.sql")):
version = migration.name
exists = conn.execute(
"SELECT 1 FROM schema_migrations WHERE version = %s", (version,)
).fetchone()
if exists:
continue
migration_sql = migration.read_text(encoding="utf-8")
for statement in migration_sql.split(";"):
if statement.strip():
conn.execute(statement)
conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (version,))
logger.info("migration applied version=%s", version)
def init_services():
global pool, redis_client, s3_client
if SESSION_TTL_SECONDS < 1:
raise RuntimeError("SESSION_TTL_SECONDS must be positive")
database_url = read_secret(DATABASE_URL_FILE)
redis_url = read_secret(REDIS_URL_FILE)
pool = ConnectionPool(
conninfo=database_url,
min_size=1,
max_size=10,
timeout=5,
kwargs={"row_factory": rows.dict_row},
open=True,
)
pool.wait(timeout=30)
redis_client = redis.Redis.from_url(
redis_url,
decode_responses=True,
socket_connect_timeout=1,
socket_timeout=1,
health_check_interval=30,
)
try:
redis_client.ping()
logger.info("session cache connected")
except redis.RedisError:
logger.warning("session cache unavailable; PostgreSQL fallback is active")
s3_client = boto3.client("s3", endpoint_url=S3_ENDPOINT,
aws_access_key_id=read_secret(S3_ACCESS_KEY_FILE),
aws_secret_access_key=read_secret(S3_SECRET_KEY_FILE),
region_name=os.getenv("S3_REGION", "us-east-1"),
config=Config(s3={"addressing_style": "path"}, connect_timeout=3, read_timeout=10, retries={"max_attempts": 2}))
def best_effort_cache_delete(key):
try:
redis_client.delete(key)
except redis.RedisError:
logger.warning("session cache delete failed; PostgreSQL remains authoritative")
def cache_session(token_hash, user_id, expires_at):
ttl = max(1, int((expires_at - now_utc()).total_seconds()))
payload = json.dumps({"user_id": str(user_id), "expires_at": format_time(expires_at)}, separators=(",", ":"))
try:
redis_client.set("session:" + token_hash, payload, ex=ttl)
except redis.RedisError:
logger.warning("session cache write failed; PostgreSQL remains authoritative")
def public_user(row):
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": format_time(row["created_at"]),
}
def public_chat(row, member_ids):
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(value) for value in member_ids],
"created_at": format_time(row["created_at"]),
}
def public_message(row):
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": format_time(row["created_at"]),
"attachment_ids": [str(x) for x in (row.get("attachment_ids") or [])],
}
def public_attachment(row):
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": format_time(row["created_at"]), "updated_at": format_time(row["updated_at"])}
def parse_limit_cursor(query):
limit_values = query.get("limit", ["50"])
cursor_values = query.get("cursor", [None])
if len(limit_values) != 1 or len(cursor_values) != 1:
raise ValueError
try:
limit = int(limit_values[0])
except (TypeError, ValueError):
raise ValueError
if limit < 1 or limit > 100 or str(limit) != limit_values[0].lstrip("+"):
raise ValueError
cursor = cursor_values[0]
if cursor == "":
raise ValueError
return limit, cursor
def authenticate_basic(header):
if not header or not header.startswith("Basic "):
return None
try:
decoded = base64.b64decode(header[6:], validate=True).decode("utf-8")
username, password = decoded.split(":", 1)
except (ValueError, UnicodeDecodeError):
return None
if not valid_username(username) or not isinstance(password, str):
return None
try:
with pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,),
).fetchone()
if row is None:
return None
password_hasher.verify(row["password_hash"], password)
return row
except (argon2_exceptions.VerifyMismatchError, argon2_exceptions.InvalidHashError, argon2_exceptions.VerificationError):
return None
def authenticate_bearer(header):
if not header or not header.startswith("Bearer "):
return None
token = header[7:].strip()
if len(token) < 32 or len(token) > 256 or " " in token:
return None
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
cached_user_id = None
try:
cached = redis_client.get("session:" + token_hash)
if cached:
cached_value = json.loads(cached)
cached_user_id = cached_value.get("user_id")
cached_expiry = dt.datetime.fromisoformat(cached_value["expires_at"].replace("Z", "+00:00"))
if cached_expiry <= now_utc() or not valid_uuid(cached_user_id):
cached_user_id = None
except (redis.RedisError, ValueError, TypeError, KeyError, AttributeError):
cached_user_id = None
logger.warning("session cache read failed; PostgreSQL fallback is active")
try:
with pool.connection() as conn:
if cached_user_id and valid_uuid(cached_user_id):
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.revoked_at IS NULL AND s.expires_at > now()
""",
(token_hash, uuid.UUID(cached_user_id)),
).fetchone()
else:
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.revoked_at IS NULL AND s.expires_at > now()
""",
(token_hash,),
).fetchone()
if row is None:
best_effort_cache_delete("session:" + token_hash)
return None
if cached_user_id is None:
cache_session(token_hash, row["id"], row["expires_at"])
return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"],
"created_at": row["created_at"], "token_hash": token_hash, "expires_at": row["expires_at"]}
except (psycopg.Error, PoolTimeout):
logger.exception("database unavailable during authentication")
raise
class MessengerServer(ThreadingHTTPServer):
daemon_threads = True
allow_reuse_address = True
class Handler(BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
def setup(self):
super().setup()
self.request_id = new_id()
self.response_status = 500
self.actor = None
self.instance_id = os.getenv("INSTANCE_ID", os.getenv("HOSTNAME", "api"))
def log_message(self, fmt, *args):
logger.info("%s %s %s request_id=%s user=%s", self.command, self.path.split("?", 1)[0],
self.response_status, self.request_id, (self.actor.get("id", "-") if self.actor else "-"))
def send_json(self, status, payload, challenge=None):
data = json_bytes(payload)
self.response_status = status
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(data)))
self.send_header("X-Request-Id", self.request_id)
self.send_header("X-Instance-Id", self.instance_id)
if challenge:
self.send_header("WWW-Authenticate", challenge)
self.end_headers()
self.wfile.write(data)
def send_empty(self, status):
self.response_status = status
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", self.instance_id)
self.end_headers()
def send_error_json(self, status, code, message, challenge=None):
self.send_json(status, error_body(code, message, self.request_id), challenge)
def unavailable(self):
self.send_error_json(503, "unavailable", "Service temporarily unavailable")
def read_body(self):
value = self.headers.get("Content-Length")
if value is None:
raise ValueError
try:
length = int(value)
except ValueError:
raise ValueError
if length < 0:
raise ValueError
if length > MAX_BODY_SIZE:
raise OverflowError
return self.rfile.read(length)
def require_json(self):
if self.headers.get_content_type() != "application/json":
self.send_error_json(415, "unsupported_media_type", "Content-Type must be application/json")
return None
try:
return parse_json_object(self.read_body())
except OverflowError:
self.send_error_json(413, "payload_too_large", "Request body is too large")
except ValueError:
self.send_error_json(400, "invalid_request", "Invalid JSON request")
return None
def identify(self):
user = authenticate_bearer(self.headers.get("Authorization"))
if user is None:
self.send_error_json(401, "unauthorized", "Valid Bearer session required",
'Bearer realm="messenger"')
return None
self.actor = user
return user
def check_ready_for_write(self):
if shutting_down:
self.send_error_json(503, "unavailable", "Service is shutting down")
return False
return True
def do_GET(self):
self.handle_method("GET")
def do_POST(self):
self.handle_method("POST")
def do_DELETE(self):
self.handle_method("DELETE")
def do_PUT(self):
self.send_error_json(404, "not_found", "Object not found")
def do_PATCH(self):
self.send_error_json(404, "not_found", "Object not found")
def handle_method(self, method):
try:
self.route(method)
except (psycopg.Error, PoolTimeout):
logger.exception("database operation failed request_id=%s", self.request_id)
if not self.wfile.closed:
try:
self.unavailable()
except OSError:
pass
except redis.RedisError:
logger.exception("cache operation failed request_id=%s", self.request_id)
if not self.wfile.closed:
try:
self.unavailable()
except OSError:
pass
except Exception:
logger.exception("unexpected request error request_id=%s", self.request_id)
if not self.wfile.closed:
try:
self.send_error_json(500, "internal_error", "Internal server error")
except OSError:
pass
def route(self, method):
parsed = urlsplit(self.path)
parts = [part for part in parsed.path.split("/") if part]
query = parse_qs(parsed.query, keep_blank_values=True)
if method == "GET" and parts == ["health", "live"]:
self.send_json(200, {"status": "ok"})
return
if method == "GET" and parts == ["health", "ready"]:
if shutting_down:
self.unavailable()
return
try:
with pool.connection() as conn:
conn.execute("SELECT 1")
s3_client.head_bucket(Bucket=S3_BUCKET)
self.send_json(200, {"status": "ok"})
except (psycopg.Error, PoolTimeout, BotoCoreError, ClientError):
self.unavailable()
return
if shutting_down:
self.unavailable()
return
if method == "POST" and parts == ["api", "v1", "users"]:
self.create_user()
return
if method == "POST" and parts == ["api", "v1", "auth", "sessions"]:
self.create_session()
return
if method == "DELETE" and parts == ["api", "v1", "auth", "sessions", "current"]:
self.delete_session()
return
if method == "GET" and parts == ["api", "v1", "users", "me"]:
user = self.identify()
if user is not None:
self.send_json(200, public_user(user))
return
if parts[:3] == ["api", "v1", "attachments"]:
if len(parts) == 4 and method == "GET" and valid_uuid(parts[3]):
self.get_attachment(parts[3], content=False)
return
if len(parts) == 5 and parts[4] == "content" and method == "GET" and valid_uuid(parts[3]):
self.get_attachment(parts[3], content=True)
return
if parts[:3] == ["api", "v1", "chats"]:
if len(parts) == 3:
if method == "POST":
self.create_chat()
return
if method == "GET":
self.list_chats(query)
return
if len(parts) == 4 and method == "GET":
if not valid_uuid(parts[3]):
if self.identify() is not None:
self.send_error_json(400, "invalid_request", "Invalid chat UUID")
return
self.get_chat(parts[3])
return
if len(parts) == 5 and parts[4] == "attachments" and method == "POST":
self.create_attachment(parts[3], query)
return
if len(parts) == 5 and parts[4] == "messages":
if not valid_uuid(parts[3]):
if self.identify() is not None:
self.send_error_json(400, "invalid_request", "Invalid chat UUID")
return
if method == "POST":
self.create_message(parts[3])
return
if method == "GET":
self.list_messages(parts[3], query)
return
self.send_error_json(404, "not_found", "Object not found")
def create_user(self):
if not self.check_ready_for_write():
return
body = self.require_json()
if body is None:
return
if not validate_keys(body, {"username", "display_name", "password"}):
self.send_error_json(400, "invalid_request", "Invalid user fields")
return
username = body["username"]
display_name = body["display_name"]
password = body["password"]
if (not valid_username(username) or not valid_nonblank_string(display_name, 100)
or not isinstance(password, str) or not 12 <= len(password) <= 128):
self.send_error_json(400, "invalid_request", "Invalid user fields")
return
password_hash = password_hasher.hash(password)
user_id = new_id()
try:
with pool.connection() as conn:
row = conn.execute(
"""
INSERT INTO users(id, username, display_name, password_hash)
VALUES (%s, %s, %s, %s)
RETURNING id, username, display_name, created_at
""",
(uuid.UUID(user_id), username, display_name, password_hash),
).fetchone()
except UniqueViolation:
self.send_error_json(409, "conflict", "Username is already in use")
return
self.send_json(201, public_user(row))
def create_session(self):
if not self.check_ready_for_write():
return
user = authenticate_basic(self.headers.get("Authorization"))
if user is None:
self.send_error_json(401, "unauthorized", "Invalid username or password",
'Basic realm="messenger", charset="UTF-8"')
return
token = secrets.token_urlsafe(32)
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
expires_at = now_utc() + dt.timedelta(seconds=SESSION_TTL_SECONDS)
with pool.connection() as conn:
conn.execute(
"INSERT INTO sessions(token_hash, user_id, expires_at) VALUES (%s, %s, %s)",
(token_hash, user["id"], expires_at),
)
cache_session(token_hash, user["id"], expires_at)
self.send_json(201, {
"token": token,
"token_type": "Bearer",
"expires_at": format_time(expires_at),
"user": public_user(user),
})
def delete_session(self):
if not self.check_ready_for_write():
return
user = self.identify()
if user is None:
return
with pool.connection() as conn:
conn.execute("UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL", (user["token_hash"],))
best_effort_cache_delete("session:" + user["token_hash"])
self.send_empty(204)
def create_chat(self):
if not self.check_ready_for_write():
return
user = self.identify()
if user is None:
return
body = self.require_json()
if body is None:
return
if not validate_keys(body, {"title", "member_ids"}):
self.send_error_json(400, "invalid_request", "Invalid chat fields")
return
title = body["title"]
member_ids = body["member_ids"]
if (not valid_nonblank_string(title, 100) or not isinstance(member_ids, list)
or not 1 <= len(member_ids) <= 100):
self.send_error_json(400, "invalid_request", "Invalid chat fields")
return
if any(not isinstance(value, str) or not valid_uuid(value) for value in member_ids):
self.send_error_json(400, "invalid_request", "Invalid chat members")
return
member_ids = [str(uuid.UUID(value)) for value in member_ids]
if len(member_ids) != len(set(member_ids)):
self.send_error_json(400, "invalid_request", "Invalid chat members")
return
if user["id"] not in member_ids:
self.send_error_json(400, "invalid_request", "Chat must include the current user")
return
chat_id = new_id()
try:
with pool.connection() as conn:
existing = conn.execute(
"SELECT id FROM users WHERE id = ANY(%s)",
([uuid.UUID(value) for value in member_ids],),
).fetchall()
if len(existing) != len(member_ids):
self.send_error_json(400, "invalid_request", "Unknown chat member")
return
row = conn.execute(
"INSERT INTO chats(id, title) VALUES (%s, %s) RETURNING id, title, created_at",
(uuid.UUID(chat_id), title),
).fetchone()
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO chat_members(chat_id, user_id, position) VALUES (%s, %s, %s)",
[(uuid.UUID(chat_id), uuid.UUID(member_id), position) for position, member_id in enumerate(member_ids)],
)
self.send_json(201, public_chat(row, member_ids))
except psycopg.errors.ForeignKeyViolation:
self.send_error_json(400, "invalid_request", "Unknown chat member")
def list_chats(self, query):
user = self.identify()
if user is None:
return
try:
limit, cursor = parse_limit_cursor(query)
except ValueError:
self.send_error_json(400, "invalid_request", "Invalid pagination parameters")
return
marker = None
if cursor is not None:
try:
marker = decode_cursor(cursor)
except ValueError:
self.send_error_json(400, "invalid_request", "Invalid cursor")
return
if marker[0] != "chats:" + user["id"]:
self.send_error_json(400, "invalid_request", "Cursor does not belong to this request")
return
sql = """
SELECT c.id, c.title, c.created_at,
array_agg(cm_all.user_id ORDER BY cm_all.position) AS member_ids
FROM chats c
JOIN chat_members cm_all ON cm_all.chat_id = c.id
WHERE EXISTS (
SELECT 1 FROM chat_members mine
WHERE mine.chat_id = c.id AND mine.user_id = %s
)
"""
params = [uuid.UUID(user["id"])]
if marker is not None:
sql += " AND (c.created_at, c.id) > (%s, %s)"
params.extend([marker[1], uuid.UUID(marker[2])])
sql += " GROUP BY c.id ORDER BY c.created_at, c.id LIMIT %s"
params.append(limit + 1)
with pool.connection() as conn:
rows = conn.execute(sql, params).fetchall()
has_more = len(rows) > limit
rows = rows[:limit]
items = [public_chat(row, row["member_ids"]) for row in rows]
next_cursor = encode_cursor("chats:" + user["id"], rows[-1]["created_at"], rows[-1]["id"]) if has_more else None
self.send_json(200, {"items": items, "next_cursor": next_cursor})
def get_chat(self, chat_id):
user = self.identify()
if user is None:
return
with pool.connection() as conn:
row = conn.execute(
"""
SELECT c.id, c.title, c.created_at,
array_agg(cm_all.user_id ORDER BY cm_all.position) AS member_ids
FROM chats c
JOIN chat_members cm_all ON cm_all.chat_id = c.id
WHERE c.id = %s AND EXISTS (
SELECT 1 FROM chat_members mine
WHERE mine.chat_id = c.id AND mine.user_id = %s
)
GROUP BY c.id
""",
(uuid.UUID(chat_id), uuid.UUID(user["id"])),
).fetchone()
if row is None:
self.send_error_json(404, "not_found", "Object not found")
return
self.send_json(200, public_chat(row, row["member_ids"]))
def create_message(self, chat_id):
if not self.check_ready_for_write():
return
user = self.identify()
if user is None:
return
key = self.headers.get("Idempotency-Key")
if not isinstance(key, str) or re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", key) is None:
self.send_error_json(400, "invalid_request", "A valid Idempotency-Key is required")
return
body = self.require_json()
if body is None:
return
if set(body) - {"text", "attachment_ids"} or "text" not in body:
self.send_error_json(400, "invalid_request", "Invalid message fields")
return
message_text = body["text"]
attachment_ids = body.get("attachment_ids", [])
if (not isinstance(message_text, str) or len(message_text) > 4000
or (not message_text.strip() and not attachment_ids)):
self.send_error_json(400, "invalid_request", "Invalid message text")
return
if (not isinstance(attachment_ids, list) or len(attachment_ids) > 10
or any(not isinstance(x, str) or not valid_uuid(x) for x in attachment_ids)):
self.send_error_json(400, "invalid_request", "Invalid attachment_ids")
return
if len(attachment_ids) != len(set(attachment_ids)):
self.send_error_json(400, "invalid_request", "Duplicate attachment_ids")
return
attachment_ids = [str(uuid.UUID(x)) for x in attachment_ids]
request_hash = hashlib.sha256(json_bytes({"text": message_text, "attachment_ids": attachment_ids})).hexdigest()
scope = f"{user['id']}:POST:/api/v1/chats/{chat_id}/messages:{key}"
message_id = new_id()
with pool.connection() as conn:
allowed = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(uuid.UUID(chat_id), uuid.UUID(user["id"])),
).fetchone()
if allowed is None:
self.send_error_json(404, "not_found", "Object not found")
return
conn.execute("SELECT pg_advisory_xact_lock(hashtextextended(%s, 0))", (scope,))
previous = conn.execute(
"SELECT request_hash, response_json FROM idempotency_keys WHERE scope = %s",
(scope,),
).fetchone()
if previous is not None:
if previous["request_hash"] != request_hash:
self.send_error_json(409, "conflict", "Idempotency-Key was used with a different request")
return
self.send_json(201, previous["response_json"])
return
if attachment_ids:
owned = conn.execute(
"SELECT id FROM attachments WHERE id = ANY(%s) AND chat_id = %s AND status = 'ready'",
([uuid.UUID(x) for x in attachment_ids], uuid.UUID(chat_id))).fetchall()
if len(owned) != len(attachment_ids):
self.send_error_json(404, "not_found", "Attachment not found")
return
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
""",
(uuid.UUID(message_id), uuid.UUID(chat_id), uuid.UUID(user["id"]), message_text),
).fetchone()
if attachment_ids:
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO message_attachments(message_id, attachment_id) VALUES (%s, %s)",
[(uuid.UUID(message_id), uuid.UUID(x)) for x in attachment_ids],
)
row["attachment_ids"] = attachment_ids
result = public_message(row)
conn.execute(
"INSERT INTO idempotency_keys(scope, request_hash, response_json, created_at) VALUES (%s, %s, %s, now())",
(scope, request_hash, json.dumps(result, ensure_ascii=False)),
)
self.send_json(201, result)
def create_attachment(self, chat_id, query):
if not self.check_ready_for_write():
return
user = self.identify()
if user is None:
return
names = query.get("filename", [])
if len(names) != 1:
self.send_error_json(400, "invalid_request", "filename is required")
return
filename = names[0]
if (not filename or len(filename) > 255 or filename in {".", ".."}
or "/" in filename or "\\\\" in filename or any(ord(c) < 32 for c in filename)):
self.send_error_json(400, "invalid_request", "Unsafe filename")
return
with pool.connection() as conn:
member = conn.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",
(uuid.UUID(chat_id), uuid.UUID(user["id"]))).fetchone()
if member is None:
self.send_error_json(404, "not_found", "Object not found")
return
length = self.headers.get("Content-Length")
try:
size = int(length)
except (TypeError, ValueError):
self.send_error_json(411, "invalid_request", "Content-Length is required")
return
if size < 1 or size > MAX_UPLOAD_BYTES:
self.send_error_json(413, "payload_too_large", "Image exceeds upload limit")
return
declared = self.headers.get_content_type()
if declared not in ("image/png", "image/jpeg"):
self.send_error_json(415, "unsupported_media_type", "Only PNG and JPEG are accepted")
return
data = self.rfile.read(size)
if len(data) != size:
self.send_error_json(400, "invalid_request", "Incomplete upload")
return
try:
image = Image.open(io.BytesIO(data))
actual = image.format
width, height = image.size
if width * height > MAX_IMAGE_PIXELS:
self.send_error_json(413, "payload_too_large", "Image dimensions exceed limit")
return
image.verify()
except (UnidentifiedImageError, OSError, Image.DecompressionBombError, Image.DecompressionBombWarning):
self.send_error_json(400, "invalid_request", "Invalid image")
return
actual_type = {"PNG": "image/png", "JPEG": "image/jpeg"}.get(actual)
if actual_type is None or actual_type != declared:
self.send_error_json(415, "unsupported_media_type", "Content-Type does not match image")
return
attachment_id = new_id()
object_key = "attachments/" + attachment_id
digest = hashlib.sha256(data).hexdigest()
try:
s3_client.put_object(Bucket=S3_BUCKET, Key=object_key, Body=data,
ContentType=actual_type, Metadata={"sha256": digest})
with pool.connection() as conn:
row = conn.execute("""
INSERT INTO attachments(id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, object_key, status)
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,'ready')
RETURNING id, chat_id, owner_id, filename, content_type, size_bytes,
sha256, status, created_at, updated_at
""", (uuid.UUID(attachment_id), uuid.UUID(chat_id), uuid.UUID(user["id"]),
filename, actual_type, size, digest, object_key)).fetchone()
self.send_json(201, public_attachment(row))
except (BotoCoreError, ClientError):
logger.exception("S3 upload failed")
self.unavailable()
except Exception:
try:
s3_client.delete_object(Bucket=S3_BUCKET, Key=object_key)
except Exception:
logger.exception("orphan cleanup failed")
raise
def get_attachment(self, attachment_id, content=False):
user = self.identify()
if user is None:
return
with pool.connection() as conn:
row = conn.execute("""
SELECT a.* FROM attachments a
JOIN chat_members cm ON cm.chat_id=a.chat_id
WHERE a.id=%s AND cm.user_id=%s AND a.status='ready'
""", (uuid.UUID(attachment_id), uuid.UUID(user["id"]))).fetchone()
if row is None:
self.send_error_json(404, "not_found", "Object not found")
return
if not content:
self.send_json(200, public_attachment(row))
return
try:
result = s3_client.get_object(Bucket=S3_BUCKET, Key=row["object_key"])
data = result["Body"].read(MAX_UPLOAD_BYTES + 1)
if len(data) > MAX_UPLOAD_BYTES or hashlib.sha256(data).hexdigest() != row["sha256"]:
self.unavailable()
return
self.response_status = 200
self.send_response(200)
self.send_header("Content-Type", row["content_type"])
self.send_header("Content-Length", str(len(data)))
self.send_header("Content-Disposition", "inline; filename*=UTF-8''" + quote(row["filename"], safe=""))
self.send_header("X-Request-Id", self.request_id)
self.send_header("X-Instance-Id", self.instance_id)
self.end_headers()
self.wfile.write(data)
except (BotoCoreError, ClientError):
logger.exception("S3 download failed")
self.unavailable()
def list_messages(self, chat_id, query):
user = self.identify()
if user is None:
return
try:
limit, cursor = parse_limit_cursor(query)
except ValueError:
self.send_error_json(400, "invalid_request", "Invalid pagination parameters")
return
marker = None
if cursor is not None:
try:
marker = decode_cursor(cursor)
except ValueError:
self.send_error_json(400, "invalid_request", "Invalid cursor")
return
if marker[0] != "messages:" + chat_id:
self.send_error_json(400, "invalid_request", "Cursor does not belong to this chat")
return
with pool.connection() as conn:
allowed = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(uuid.UUID(chat_id), uuid.UUID(user["id"])),
).fetchone()
if allowed is None:
self.send_error_json(404, "not_found", "Object not found")
return
sql = """
SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at,
COALESCE(array_agg(ma.attachment_id) FILTER (WHERE ma.attachment_id IS NOT NULL), ARRAY[]::uuid[]) AS attachment_ids
FROM messages m
LEFT JOIN message_attachments ma ON ma.message_id = m.id
WHERE m.chat_id = %s
"""
params = [uuid.UUID(chat_id)]
if marker is not None:
sql += " AND (created_at, id) > (%s, %s)"
params.extend([marker[1], uuid.UUID(marker[2])])
sql += " GROUP BY m.id ORDER BY m.created_at, m.id LIMIT %s"
params.append(limit + 1)
rows = conn.execute(sql, params).fetchall()
has_more = len(rows) > limit
rows = rows[:limit]
items = [public_message(row) for row in rows]
next_cursor = encode_cursor("messages:" + chat_id, rows[-1]["created_at"], rows[-1]["id"]) if has_more else None
self.send_json(200, {"items": items, "next_cursor": next_cursor})
def handle_signal(signum, frame):
global shutting_down
shutting_down = True
logger.info("shutdown requested signal=%s", signum)
if server is not None:
threading.Thread(target=server.shutdown, daemon=True).start()
def main():
global server
init_services()
if len(sys.argv) > 1 and sys.argv[1] == "migrate":
apply_migrations()
pool.close()
redis_client.close()
return
server = MessengerServer((HOST, PORT), Handler)
signal.signal(signal.SIGTERM, handle_signal)
signal.signal(signal.SIGINT, handle_signal)
logger.info("server started host=%s port=%s", HOST, PORT)
try:
server.serve_forever(poll_interval=0.2)
finally:
server.server_close()
if pool is not None:
pool.close()
if redis_client is not None:
redis_client.close()
logger.info("server stopped")
if __name__ == "__main__":
main()