Files
mtusi2026lab2/server.py
T

797 lines
29 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
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)
apply_migrations()
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
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)
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.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.dispatch("GET")
def do_POST(self):
self.dispatch("POST")
def do_DELETE(self):
self.dispatch("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 dispatch(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()
conn.cursor().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 = [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), 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
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
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), user["id"]),
).fetchone()
if allowed is None:
self.send_error_json(404, "not_found", "Object 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), user["id"], message_text),
).fetchone()
self.send_json(201, public_message(row))
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), 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()
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()