forked from mtusi2026/mtusi2026lab4
1004 lines
40 KiB
Python
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() |