"""HTTP API for laboratory 2 (PostgreSQL + opaque sessions in Redis).""" from __future__ import annotations import json import logging import time import uuid from datetime import datetime, timezone import psycopg import psycopg_pool import redis from argon2 import PasswordHasher from argon2.exceptions import InvalidHashError, VerifyMismatchError from flask import Flask, Response, g, request from . import db, sessions from .config import settings from .errors import ApiError, bad_request, conflict, not_found, unauthorized, unavailable from .validation import ( cursor_time, decode_cursor, display_name, encode_cursor, exact_keys, json_object, limit_arg, message_text, non_blank, password, username, uuid_list, uuid_value, ) logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s") log = logging.getLogger("messenger.api") app = Flask(__name__) app.config["MAX_CONTENT_LENGTH"] = settings.max_body_bytes hasher = PasswordHasher() # --------------------------------------------------------------------------- # Response helpers and middleware # --------------------------------------------------------------------------- def _json(payload: object, status: int = 200, headers: dict[str, str] | None = None) -> Response: body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")) response = Response(body, status=status, mimetype="application/json") for key, value in (headers or {}).items(): response.headers[key] = value return response def _error_response(error: ApiError, request_id: str) -> Response: return _json( { "error": { "code": error.code, "message": error.message, "request_id": request_id, } }, error.status, error.headers, ) @app.before_request def _request_context() -> None: g.request_id = uuid.uuid4().hex g.started_at = time.monotonic() db.start_background_initialisation() @app.after_request def _response_headers(response: Response) -> Response: response.headers["X-Request-Id"] = g.get("request_id", uuid.uuid4().hex) response.headers["Cache-Control"] = "no-store" return response @app.errorhandler(ApiError) def _handle_api_error(error: ApiError) -> Response: return _error_response(error, g.get("request_id", uuid.uuid4().hex)) @app.errorhandler(413) def _handle_too_large(_error: object) -> Response: return _error_response( ApiError(413, "payload_too_large", "Тело запроса слишком велико"), g.get("request_id", uuid.uuid4().hex), ) @app.errorhandler(404) def _handle_not_found(_error: object) -> Response: return _error_response(not_found(), g.get("request_id", uuid.uuid4().hex)) @app.errorhandler(405) def _handle_method(_error: object) -> Response: return _error_response(bad_request("Метод не поддерживается"), g.get("request_id", uuid.uuid4().hex)) @app.errorhandler(Exception) def _handle_unexpected(error: Exception) -> Response: request_id = g.get("request_id", uuid.uuid4().hex) if isinstance(error, (psycopg.OperationalError, psycopg_pool.PoolTimeout, psycopg_pool.PoolClosed)): log.warning("database unavailable on %s %s: %s", request.method, request.path, type(error).__name__) return _error_response(unavailable("База данных недоступна"), request_id) if isinstance(error, redis.RedisError): log.warning("session store unavailable on %s %s: %s", request.method, request.path, type(error).__name__) return _error_response(unavailable("Хранилище сессий недоступно"), request_id) log.exception("unhandled error on %s %s", request.method, request.path) return _error_response( ApiError(500, "internal_error", "Внутренняя ошибка сервера"), request_id ) # --------------------------------------------------------------------------- # Serialisation # --------------------------------------------------------------------------- def format_time(value: datetime) -> str: return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ") def user_json(row: dict) -> dict: return { "id": str(row["id"]), "username": row["username"], "display_name": row["display_name"], "created_at": format_time(row["created_at"]), } def chat_json(row: dict) -> dict: member_ids = sorted(str(item) for item in (row.get("member_ids") or [])) return { "id": str(row["id"]), "title": row["title"], "member_ids": member_ids, "created_at": format_time(row["created_at"]), } def message_json(row: dict) -> dict: 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"]), } # --------------------------------------------------------------------------- # Authentication # --------------------------------------------------------------------------- def _bearer_token() -> str: header = request.headers.get("Authorization", "") parts = header.split(None, 1) if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1].strip(): raise unauthorized() return parts[1].strip() def current_user() -> dict: cached = g.get("current_user") if cached is not None: return cached token = _bearer_token() user_id, token_digest = sessions.resolve(token) if not user_id: raise unauthorized() try: parsed = uuid.UUID(user_id) except ValueError as exc: raise unauthorized() from exc with db.pool().connection() as conn: row = conn.execute( "SELECT id, username, display_name, created_at FROM users WHERE id = %s", (parsed,), ).fetchone() if row is None: sessions.revoke(token_digest) raise unauthorized() g.current_user = row g.session_token_digest = token_digest return row def _basic_credentials() -> tuple[str, str]: header = request.headers.get("Authorization", "") parts = header.split(None, 1) if len(parts) != 2 or parts[0].lower() != "basic": raise unauthorized(basic=True) import base64 try: decoded = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8") except (ValueError, UnicodeError) as exc: raise unauthorized(basic=True) from exc name, separator, secret = decoded.partition(":") if not separator or not name or not secret: raise unauthorized(basic=True) if len(name) > 32 or any(ord(char) > 127 for char in name): raise unauthorized(basic=True) return name, secret def _authenticate_basic() -> dict: name, secret = _basic_credentials() with db.pool().connection() as conn: row = conn.execute( "SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s", (name,), ).fetchone() if row is None: raise unauthorized(basic=True) try: hasher.verify(row["password_hash"], secret) except (VerifyMismatchError, InvalidHashError): raise unauthorized(basic=True) return row # --------------------------------------------------------------------------- # Health # --------------------------------------------------------------------------- @app.get("/health/live") def health_live() -> Response: return _json({"status": "ok"}) @app.get("/health/ready") def health_ready() -> Response: if not db.is_migrated(): raise unavailable("База данных ещё не готова") try: with db.pool().connection(timeout=1.0) as conn: conn.execute("SELECT 1") except Exception as exc: raise unavailable("База данных недоступна") from exc sessions.ping() return _json({"status": "ok"}) # --------------------------------------------------------------------------- # Users and sessions # --------------------------------------------------------------------------- @app.post("/api/v1/users") def register_user() -> Response: body = json_object(request, settings.max_body_bytes) exact_keys(body, ("username", "display_name", "password")) name = username(body["username"]) shown_name = display_name(body["display_name"]) secret = password(body["password"]) user_id = uuid.uuid4() try: with db.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 """, (user_id, name, shown_name, hasher.hash(secret)), ).fetchone() except psycopg.errors.UniqueViolation as exc: raise conflict("Username уже занят") from exc return _json(user_json(row), 201) @app.post("/api/v1/auth/sessions") def create_session() -> Response: row = _authenticate_basic() token, expires_at = sessions.create(str(row["id"])) return _json( { "token": token, "token_type": "Bearer", "expires_at": format_time(expires_at), "user": user_json(row), }, 201, ) @app.delete("/api/v1/auth/sessions/current") def revoke_session() -> Response: current_user() # authentication must happen before revocation sessions.revoke(g.session_token_digest) return Response(status=204) @app.get("/api/v1/users/me") def current_user_endpoint() -> Response: return _json(user_json(current_user())) # --------------------------------------------------------------------------- # Chats # --------------------------------------------------------------------------- def _require_chat_member(chat_id: uuid.UUID, user_id: uuid.UUID) -> None: with db.pool().connection() as conn: row = conn.execute( "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id), ).fetchone() if row is None: raise not_found() @app.post("/api/v1/chats") def create_chat() -> Response: actor = current_user() body = json_object(request, settings.max_body_bytes) exact_keys(body, ("title", "member_ids")) title = non_blank(body["title"], "title", 1, 100) member_ids = uuid_list(body["member_ids"], "member_ids") actor_id = str(actor["id"]) if actor_id not in member_ids: raise bad_request("Создатель должен входить в member_ids") member_uuids = [uuid.UUID(item) for item in member_ids] chat_id = uuid.uuid4() with db.pool().connection() as conn: existing = conn.execute( "SELECT id FROM users WHERE id = ANY(%s)", (member_uuids,) ).fetchall() if len(existing) != len(member_uuids): raise bad_request("Указан неизвестный участник") row = conn.execute( "INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at", (chat_id, title), ).fetchone() with conn.cursor() as cursor: cursor.executemany( "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", [(chat_id, member) for member in member_uuids], ) payload = dict(row) payload["member_ids"] = member_uuids return _json(chat_json(payload), 201) @app.get("/api/v1/chats") def list_chats() -> Response: actor = current_user() limit = limit_arg(request.args.get("limit")) cursor = decode_cursor(request.args.get("cursor")) parameters: list[object] = [actor["id"]] predicate = "" if cursor is not None: if cursor.get("kind") != "chats" or cursor.get("user_id") != str(actor["id"]): raise bad_request("Некорректный cursor") try: cursor_created = cursor_time(cursor.get("created_at")) cursor_id = uuid_value(cursor.get("id"), "cursor") except ApiError: raise bad_request("Некорректный cursor") predicate = "AND (c.created_at, c.id) > (%s, %s)" parameters.extend([cursor_created, cursor_id]) parameters.append(limit + 1) query = f""" SELECT c.id, c.title, c.created_at, ARRAY( SELECT cm.user_id FROM chat_members cm WHERE cm.chat_id = c.id ORDER BY cm.user_id ) AS member_ids FROM chats c JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s WHERE TRUE {predicate} ORDER BY c.created_at, c.id LIMIT %s """ with db.pool().connection() as conn: rows = conn.execute(query, tuple(parameters)).fetchall() page = rows[:limit] next_cursor = None if len(rows) > limit and page: last = page[-1] next_cursor = encode_cursor( { "v": 1, "kind": "chats", "user_id": str(actor["id"]), "created_at": format_time(last["created_at"]), "id": str(last["id"]), } ) return _json({"items": [chat_json(row) for row in page], "next_cursor": next_cursor}) @app.get("/api/v1/chats/") def get_chat(chat_id: str) -> Response: actor = current_user() parsed_chat_id = uuid_value(chat_id, "chat_id") with db.pool().connection() as conn: row = conn.execute( """ SELECT c.id, c.title, c.created_at, ARRAY( SELECT cm.user_id FROM chat_members cm WHERE cm.chat_id = c.id ORDER BY cm.user_id ) AS member_ids FROM chats c JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s WHERE c.id = %s """, (actor["id"], parsed_chat_id), ).fetchone() if row is None: raise not_found() return _json(chat_json(row)) # --------------------------------------------------------------------------- # Messages # --------------------------------------------------------------------------- @app.post("/api/v1/chats//messages") def create_message(chat_id: str) -> Response: actor = current_user() parsed_chat_id = uuid_value(chat_id, "chat_id") _require_chat_member(parsed_chat_id, actor["id"]) body = json_object(request, settings.max_body_bytes) exact_keys(body, ("text",)) text = message_text(body["text"]) with db.pool().connection() as conn: 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.uuid4(), parsed_chat_id, actor["id"], text), ).fetchone() return _json(message_json(row), 201) @app.get("/api/v1/chats//messages") def list_messages(chat_id: str) -> Response: actor = current_user() parsed_chat_id = uuid_value(chat_id, "chat_id") _require_chat_member(parsed_chat_id, actor["id"]) limit = limit_arg(request.args.get("limit")) cursor = decode_cursor(request.args.get("cursor")) parameters: list[object] = [parsed_chat_id] predicate = "" if cursor is not None: if cursor.get("kind") != "messages" or cursor.get("chat_id") != str(parsed_chat_id): raise bad_request("Некорректный cursor") try: cursor_created = cursor_time(cursor.get("created_at")) cursor_id = uuid_value(cursor.get("id"), "cursor") except ApiError: raise bad_request("Некорректный cursor") predicate = "AND (created_at, id) > (%s, %s)" parameters.extend([cursor_created, cursor_id]) parameters.append(limit + 1) query = f""" SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s {predicate} ORDER BY created_at, id LIMIT %s """ with db.pool().connection() as conn: rows = conn.execute(query, tuple(parameters)).fetchall() page = rows[:limit] next_cursor = None if len(rows) > limit and page: last = page[-1] next_cursor = encode_cursor( { "v": 1, "kind": "messages", "chat_id": str(parsed_chat_id), "created_at": format_time(last["created_at"]), "id": str(last["id"]), } ) return _json({"items": [message_json(row) for row in page], "next_cursor": next_cursor})