Files
mtusi2026lab2/app/server.py
T
2026-10-29 17:16:55 +03:00

301 lines
12 KiB
Python

import base64
import binascii
import json
import socket
import psycopg
from psycopg_pool import PoolTimeout, TooManyRequests
import logging
import re
import time
import urllib.parse
import uuid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Any, Dict, Optional, Tuple
from app.errors import (
APIError,
BadRequestError,
InternalError,
NotFoundError,
UnauthorizedError,
UnavailableError,
)
from app.models import (
parse_limit,
validate_create_chat,
validate_create_message,
validate_create_user,
validate_uuid,
)
from app.storage import PostgresStorage
logger = logging.getLogger("messenger")
CHAT_MESSAGES_PATTERN = re.compile(r"^/api/v1/chats/([^/]+)/messages$")
CHAT_DETAIL_PATTERN = re.compile(r"^/api/v1/chats/([^/]+)$")
class MessengerHandler(BaseHTTPRequestHandler):
server_version = "MTUSI-Messenger/1.0"
@property
def storage(self) -> PostgresStorage:
return self.server.storage # type: ignore
@property
def is_shutting_down(self) -> bool:
return getattr(self.server, "is_shutting_down", False)
def log_message(self, format: str, *args: Any):
# Suppress default BaseHTTPRequestHandler noisy log
pass
def _get_request_id(self) -> str:
return str(uuid.uuid4())
def setup(self):
super().setup()
self.connection.settimeout(10)
def _send_json(self, status_code: int, data: Optional[Dict[str, Any]], request_id: str):
body = b""
if data is not None and status_code != 204:
body = json.dumps(data, ensure_ascii=False).encode("utf-8")
self.send_response(status_code)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.send_header("X-Request-Id", request_id)
if status_code == 401:
challenge = ('Basic realm="messenger", charset="UTF-8"' if
urllib.parse.urlparse(self.path).path == '/api/v1/auth/sessions'
else 'Bearer realm="messenger"')
self.send_header('WWW-Authenticate', challenge)
self.end_headers()
if body:
self.wfile.write(body)
def _send_error(self, err: APIError, request_id: str):
payload = err.to_dict(request_id)
self._send_json(err.status_code, payload, request_id)
def _read_json_body(self) -> Any:
if self.headers.get('Transfer-Encoding'):
raise BadRequestError('Transfer-Encoding is not supported')
if self.headers.get_content_type() != 'application/json':
raise APIError('unsupported_media_type', 'Expected application/json', 415)
content_length_header = self.headers.get("Content-Length")
if not content_length_header:
raise BadRequestError("Missing request body")
try:
content_length = int(content_length_header)
except (ValueError, TypeError):
raise BadRequestError("Invalid Content-Length header")
if content_length < 0 or content_length > 10 * 1024 * 1024:
raise BadRequestError("Payload size invalid")
raw_data = self.rfile.read(content_length)
if not raw_data:
raise BadRequestError("Empty request body")
try:
body = json.loads(raw_data.decode("utf-8"))
# Reject unpaired surrogates before a driver/KDF tries to encode them.
json.dumps(body, ensure_ascii=False).encode('utf-8')
return body
except (ValueError, UnicodeError):
raise BadRequestError("Malformed JSON in request body")
def _bearer(self):
parts = self.headers.get('Authorization', '').split()
if len(parts) != 2 or parts[0].lower() != 'bearer' or len(parts[1]) > 512:
raise UnauthorizedError()
return parts[1]
def _authenticate_user(self):
return self.storage.authenticate(self._bearer())
def _login(self):
parts = self.headers.get('Authorization', '').split()
if len(parts) != 2 or parts[0].lower() != 'basic' or len(parts[1]) > 2048:
raise UnauthorizedError('Invalid credentials')
try:
credential = base64.b64decode(parts[1], validate=True).decode('utf-8')
username, password = credential.split(':', 1)
if not re.fullmatch(r'[a-z0-9_]{3,32}', username) or not 12 <= len(password) <= 128:
raise ValueError
except (ValueError, UnicodeError, binascii.Error):
raise UnauthorizedError('Invalid credentials') from None
if self.headers.get('Transfer-Encoding') or self.headers.get('Content-Length', '0') != '0':
raise BadRequestError('Session creation has no body')
return self.storage.login(username, password)
def do_PUT(self):
self._handle_request("PUT")
def do_PATCH(self):
self._handle_request("PATCH")
def do_OPTIONS(self):
self._handle_request("OPTIONS")
def do_DELETE(self):
self._handle_request("DELETE")
def do_GET(self):
self._handle_request("GET")
def do_POST(self):
self._handle_request("POST")
def _handle_request(self, method: str):
start_time = time.monotonic()
request_id = self._get_request_id()
parsed_url = urllib.parse.urlparse(self.path)
path = parsed_url.path
query = urllib.parse.parse_qs(parsed_url.query, keep_blank_values=True)
status_code = 200
try:
if self.is_shutting_down and not path.startswith("/health/"):
raise UnavailableError("Server is shutting down")
# Route dispatcher
if method == "GET" and path == "/health/live":
self._send_json(200, {"status": "ok"}, request_id)
status_code = 200
elif method == "GET" and path == "/health/ready":
if self.is_shutting_down:
raise UnavailableError("Server is shutting down")
self.storage.ready()
self._send_json(200, {"status": "ok"}, request_id)
status_code = 200
elif method == "POST" and path == "/api/v1/users":
body = self._read_json_body()
validated = validate_create_user(body)
user = self.storage.create_user(**validated)
self._send_json(201, user, request_id)
status_code = 201
elif method == 'POST' and path == '/api/v1/auth/sessions':
self._send_json(201, self._login(), request_id)
status_code = 201
elif method == 'DELETE' and path == '/api/v1/auth/sessions/current':
self.storage.logout(self._bearer())
self._send_json(204, None, request_id)
status_code = 204
elif method == "GET" and path == "/api/v1/users/me":
actor = self._authenticate_user()
self._send_json(200, actor, request_id)
status_code = 200
elif method == "POST" and path == "/api/v1/chats":
actor = self._authenticate_user()
body = self._read_json_body()
validated = validate_create_chat(body)
chat = self.storage.create_chat(
creator_id=actor["id"],
title=validated["title"],
member_ids=validated["member_ids"],
)
self._send_json(201, chat, request_id)
status_code = 201
elif method == "GET" and path == "/api/v1/chats":
actor = self._authenticate_user()
limit_val = query.get("limit", [None])[0]
cursor_val = query.get("cursor", [None])[0]
limit = parse_limit(limit_val)
result = self.storage.list_chats(actor["id"], limit=limit, cursor=cursor_val)
self._send_json(200, result, request_id)
status_code = 200
else:
# Check regex routes
match_messages = CHAT_MESSAGES_PATTERN.match(path)
match_chat = CHAT_DETAIL_PATTERN.match(path)
if match_messages:
raw_chat_id = match_messages.group(1)
actor = self._authenticate_user()
chat_id = validate_uuid(raw_chat_id, "chat_id")
if method == "POST":
body = self._read_json_body()
validated = validate_create_message(body)
msg = self.storage.create_message(
chat_id=chat_id,
sender_id=actor["id"],
text=validated["text"],
)
self._send_json(201, msg, request_id)
status_code = 201
elif method == "GET":
limit_val = query.get("limit", [None])[0]
cursor_val = query.get("cursor", [None])[0]
limit = parse_limit(limit_val)
result = self.storage.list_messages(
user_id=actor["id"],
chat_id=chat_id,
limit=limit,
cursor=cursor_val,
)
self._send_json(200, result, request_id)
status_code = 200
else:
raise NotFoundError("Endpoint not found")
elif match_chat:
raw_chat_id = match_chat.group(1)
actor = self._authenticate_user()
chat_id = validate_uuid(raw_chat_id, "chat_id")
if method == "GET":
chat = self.storage.get_chat(user_id=actor["id"], chat_id=chat_id)
self._send_json(200, chat, request_id)
status_code = 200
else:
raise NotFoundError("Endpoint not found")
else:
raise NotFoundError(f"Route not found: {method} {path}")
except APIError as err:
status_code = err.status_code
self._send_error(err, request_id)
except (psycopg.OperationalError, psycopg.InterfaceError, psycopg.errors.QueryCanceled,
psycopg.errors.LockNotAvailable, PoolTimeout, TooManyRequests):
status_code = 503
self._send_error(UnavailableError(), request_id)
except (socket.timeout, ConnectionError):
status_code = 408
self.close_connection = True
except Exception as exc:
status_code = 500
logger.error("Unhandled exception type: %s", type(exc).__name__)
self._send_error(InternalError("Internal server error"), request_id)
finally:
elapsed_ms = (time.monotonic() - start_time) * 1000
# Safe structured log without payload content
logger.info(
"%s %s %d %.2fms req_id=%s",
method,
path,
status_code,
elapsed_ms,
request_id,
)
class MessengerServer(ThreadingHTTPServer):
daemon_threads = True
def __init__(self, server_address: Tuple[str, int], storage: Optional[PostgresStorage] = None):
super().__init__(server_address, MessengerHandler)
self.storage = storage or PostgresStorage()
self.is_shutting_down = False