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 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path from urllib.parse import parse_qs, urlsplit import psycopg from psycopg import rows from psycopg.errors import UniqueViolation from psycopg_pool import ConnectionPool, PoolTimeout import redis 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 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 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") 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"]), } 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") self.send_json(200, {"status": "ok"}) except (psycopg.Error, PoolTimeout): 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", "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] == "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 not validate_keys(body, {"text"}): self.send_error_json(400, "invalid_request", "Invalid message fields") return message_text = body["text"] if not isinstance(message_text, str) or len(message_text) > 4000 or not message_text.strip(): self.send_error_json(400, "invalid_request", "Invalid message text") return request_hash = hashlib.sha256(json_bytes({"text": message_text})).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 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() 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 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 id, chat_id, sender_id, text, created_at FROM messages WHERE 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 += " ORDER BY created_at, 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()