forked from mtusi2026/mtusi2026lab4
- python -m messenger.reconcile: merge-join листинга S3 и attachments по object_key; dry-run read-only конструктивно (default_transaction_read_only + S3 без записи), --apply: orphan/stale intent удаляются, ready-строки только в карантин (обратимо), перепроверка под FOR UPDATE, предохранитель от массового удаления; - attachment_ids хранится в строке сообщения (история остаётся одним index range scan), message_attachments — для FK и обратного поиска; - семафор полной проверки изображений (IMAGE_VERIFY_CONCURRENCY); - тесты: вложения (56), отказ/пауза S3 и деградированный режим LB, failover загрузки, приватность bucket, FAULT_POINTS после PUT/после COMMIT, janitor, reconciler; - бенчмарки памяти загрузок и стоимости обхода reconciler. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
574 lines
29 KiB
Python
574 lines
29 KiB
Python
"""HTTP layer: Starlette routes, request-id/logging middleware and error mapping."""
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import contextlib
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import random
|
|
import re
|
|
import time
|
|
import uuid
|
|
from typing import Any
|
|
|
|
from starlette.applications import Starlette
|
|
from starlette.exceptions import HTTPException
|
|
from starlette.requests import Request
|
|
from starlette.responses import JSONResponse, Response, StreamingResponse
|
|
from starlette.routing import Route
|
|
from starlette.types import ASGIApp, Message as AsgiMessage, Receive, Scope, Send
|
|
|
|
from . import attachments, authhdr, cursor, docs, passwords, repo, validation
|
|
from .config import Settings
|
|
from .db import Database
|
|
from .errors import BASIC_CHALLENGE, ApiError, InvalidRequest, NotFound, PayloadTooLarge, Unauthorized, Unavailable
|
|
from .sessions import SessionStore, build_store
|
|
from .storage import ObjectMissing, Storage
|
|
from .timefmt import rfc3339
|
|
|
|
log = logging.getLogger("messenger")
|
|
access_log = logging.getLogger("messenger.access")
|
|
|
|
REQUEST_ID_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}")
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Responses
|
|
# --------------------------------------------------------------------------
|
|
def error_response(request_id: str, status: int, code: str, message: str, headers: dict[str, str] | None = None) -> JSONResponse:
|
|
body = {"error": {"code": code, "message": message, "request_id": request_id}}
|
|
return JSONResponse(body, status_code=status, headers={"X-Request-Id": request_id, **(headers or {})})
|
|
|
|
|
|
async def api_error_handler(request: Request, exc: Exception) -> JSONResponse:
|
|
assert isinstance(exc, ApiError)
|
|
return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers)
|
|
|
|
|
|
async def http_exception_handler(request: Request, exc: Exception) -> JSONResponse:
|
|
"""Unknown routes and wrong methods also answer in the contract error format."""
|
|
assert isinstance(exc, HTTPException)
|
|
if exc.status_code == 404:
|
|
return error_response(request.state.request_id, 404, "not_found", "Объект не найден")
|
|
if exc.status_code == 405:
|
|
return error_response(request.state.request_id, 405, "invalid_request", "Метод не поддерживается", exc.headers)
|
|
return error_response(request.state.request_id, exc.status_code, "invalid_request", "Неверный запрос")
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Middleware (pure ASGI, so it also covers 404/405 and unexpected exceptions)
|
|
# --------------------------------------------------------------------------
|
|
class RequestContextMiddleware:
|
|
"""Adds X-Request-Id and X-Instance-Id to EVERY response (errors, health and crash 500/503
|
|
included), writes one access-log line, turns crashes into 500."""
|
|
|
|
def __init__(self, app: ASGIApp, instance_id: str):
|
|
self.app = app
|
|
self.instance_id = instance_id.encode("ascii")
|
|
|
|
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
|
|
if scope["type"] != "http":
|
|
await self.app(scope, receive, send)
|
|
return
|
|
incoming = dict(scope["headers"]).get(b"x-request-id", b"").decode("latin-1")
|
|
request_id = incoming if REQUEST_ID_RE.fullmatch(incoming) else uuid.uuid4().hex
|
|
scope.setdefault("state", {})["request_id"] = request_id
|
|
status = 500
|
|
started = False
|
|
begin = time.perf_counter()
|
|
|
|
async def send_with_id(message: AsgiMessage) -> None:
|
|
nonlocal status, started
|
|
if message["type"] == "http.response.start":
|
|
started = True
|
|
status = message["status"]
|
|
headers = [(k, v) for k, v in message.get("headers", [])
|
|
if k.lower() not in (b"x-request-id", b"x-instance-id")]
|
|
headers.append((b"x-request-id", request_id.encode("latin-1")))
|
|
headers.append((b"x-instance-id", self.instance_id))
|
|
message = {**message, "headers": headers}
|
|
await send(message)
|
|
|
|
try:
|
|
await self.app(scope, receive, send_with_id)
|
|
except asyncio.CancelledError:
|
|
# uvicorn cancels requests still running when SHUTDOWN_TIMEOUT_SECONDS expires:
|
|
# answer 503 (retryable) instead of a generic 500, then let the cancellation proceed.
|
|
if not started:
|
|
status = 503
|
|
response = error_response(request_id, 503, "unavailable", "Сервер завершает работу")
|
|
await response(scope, receive, send_with_id)
|
|
raise
|
|
except Exception:
|
|
log.exception("unhandled_error", extra={"fields": {"request_id": request_id}})
|
|
if not started:
|
|
status = 500
|
|
response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера")
|
|
await response(scope, receive, send_with_id)
|
|
finally:
|
|
access_log.info("request", extra={"fields": {
|
|
"request_id": request_id,
|
|
"method": scope["method"],
|
|
"path": scope["path"], # ids only; query (cursor) and bodies are never logged
|
|
"status": status,
|
|
"instance_id": self.instance_id.decode("ascii"),
|
|
"duration_ms": round((time.perf_counter() - begin) * 1000, 3),
|
|
}})
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Request helpers
|
|
# --------------------------------------------------------------------------
|
|
def db_of(request: Request) -> Database:
|
|
return request.app.state.db
|
|
|
|
|
|
def sessions_of(request: Request) -> SessionStore:
|
|
return request.app.state.sessions
|
|
|
|
|
|
def storage_of(request: Request) -> Storage:
|
|
return request.app.state.storage
|
|
|
|
|
|
async def authenticate(request: Request) -> str:
|
|
"""User id of a valid Bearer session, otherwise 401. X-User-Id is ignored since lab 2.
|
|
|
|
Store failures are 503 (Unavailable), never 401 and never anonymous access.
|
|
"""
|
|
token = authhdr.parse_bearer(request.headers.get("authorization"))
|
|
user_id = await sessions_of(request).user_id_for(token)
|
|
if user_id is None:
|
|
raise Unauthorized("Сессия недействительна, истекла или отозвана")
|
|
return user_id
|
|
|
|
|
|
def path_uuid(request: Request, name: str) -> str:
|
|
return validation.parse_uuid(request.path_params[name], name)
|
|
|
|
|
|
async def read_json(request: Request) -> dict[str, Any]:
|
|
content_type = request.headers.get("content-type", "")
|
|
media_type, _, params = content_type.partition(";")
|
|
if media_type.strip().lower() != "application/json":
|
|
raise InvalidRequest("Content-Type должен быть application/json")
|
|
charset = params.strip().lower()
|
|
if charset and charset.replace(" ", "") not in {"charset=utf-8", "charset=\"utf-8\""}:
|
|
raise InvalidRequest("Поддерживается только кодировка UTF-8")
|
|
limit: int = request.app.state.settings.max_body_bytes
|
|
declared = request.headers.get("content-length")
|
|
if declared is not None and declared.isdigit() and int(declared) > limit:
|
|
raise PayloadTooLarge()
|
|
chunks: list[bytes] = []
|
|
size = 0
|
|
async for chunk in request.stream():
|
|
size += len(chunk)
|
|
if size > limit:
|
|
raise PayloadTooLarge()
|
|
chunks.append(chunk)
|
|
return validation.parse_json_object(b"".join(chunks))
|
|
|
|
|
|
def page_params(request: Request) -> tuple[int, str | None]:
|
|
query = request.query_params.multi_items()
|
|
limit = validation.parse_limit(validation.single_query_param(query, "limit"))
|
|
raw_cursor = validation.single_query_param(query, "cursor")
|
|
if raw_cursor is not None and raw_cursor == "":
|
|
raise InvalidRequest("cursor не может быть пустым")
|
|
return limit, raw_cursor
|
|
|
|
|
|
async def reject_body(request: Request) -> None:
|
|
"""POST /auth/sessions takes credentials only from the Basic header; any body is 400."""
|
|
if request.headers.get("transfer-encoding") or request.headers.get("content-length", "0") != "0":
|
|
raise InvalidRequest("Вход принимает только заголовок Authorization: Basic, без тела")
|
|
async for chunk in request.stream():
|
|
if chunk:
|
|
raise InvalidRequest("Вход принимает только заголовок Authorization: Basic, без тела")
|
|
|
|
|
|
def idempotency_key(request: Request) -> str:
|
|
values = request.headers.getlist("idempotency-key")
|
|
return validation.idempotency_key(values[0] if len(values) == 1 else None)
|
|
|
|
|
|
def request_fingerprint(text: str, attachment_ids: list[str]) -> bytes:
|
|
"""SHA-256 of the canonical body: key order and an absent attachment_ids vs [] do not matter."""
|
|
canonical = json.dumps({"attachment_ids": attachment_ids, "text": text},
|
|
ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
|
return hashlib.sha256(canonical.encode("utf-8")).digest()
|
|
|
|
|
|
def ok(body: Any, status: int = 200) -> JSONResponse:
|
|
return JSONResponse(body, status_code=status)
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Handlers
|
|
# --------------------------------------------------------------------------
|
|
async def live(request: Request) -> JSONResponse:
|
|
return ok({"status": "ok"})
|
|
|
|
|
|
async def ready(request: Request) -> JSONResponse:
|
|
"""200 only if the WHOLE mandatory synchronous path can be served: PostgreSQL, Valkey
|
|
(SESSION_STORE=valkey) and, since lab 4, the S3 bucket (upload/download of attachments)
|
|
answer. 503 while draining after SIGTERM. HAProxy routes to such replicas first."""
|
|
if request.app.state.draining:
|
|
raise Unavailable("Сервер завершает работу")
|
|
db_ok, store_ok, s3_ok = await asyncio.gather(db_of(request).ping(), sessions_of(request).ping(),
|
|
storage_of(request).ping())
|
|
if not db_ok:
|
|
raise Unavailable("PostgreSQL недоступен")
|
|
if not store_ok:
|
|
raise Unavailable("Хранилище сессий недоступно")
|
|
if not s3_ok:
|
|
raise Unavailable("Хранилище файлов (S3) недоступно")
|
|
return ok({"status": "ok"})
|
|
|
|
|
|
async def ready_core(request: Request) -> JSONResponse:
|
|
"""Not in the contract: readiness WITHOUT S3, for the load balancer's degraded mode only.
|
|
If S3 is down for every replica, /health/ready is 503 everywhere; HAProxy then routes to
|
|
replicas that are at least core-ready, so chats and messages keep working while every
|
|
attachment request answers 503 itself (see infra/haproxy/haproxy.cfg)."""
|
|
if request.app.state.draining:
|
|
raise Unavailable("Сервер завершает работу")
|
|
db_ok, store_ok = await asyncio.gather(db_of(request).ping(), sessions_of(request).ping())
|
|
if not (db_ok and store_ok):
|
|
raise Unavailable("PostgreSQL или хранилище сессий недоступно")
|
|
return ok({"status": "ok"})
|
|
|
|
|
|
async def register_user(request: Request) -> JSONResponse:
|
|
data = await read_json(request)
|
|
validation.check_fields(data, {"username", "display_name", "password"})
|
|
username = validation.username_field(data)
|
|
display_name = validation.text_field(data, "display_name", 100)
|
|
password = validation.password_field(data)
|
|
password_hash = await passwords.hash_password(password)
|
|
user = await repo.create_user(db_of(request), username, display_name, password_hash)
|
|
log.info("user_created", extra={"fields": {"request_id": request.state.request_id, "user_id": user.id}})
|
|
return ok(user.to_json(), 201)
|
|
|
|
|
|
async def create_session(request: Request) -> JSONResponse:
|
|
"""Login: only `Authorization: Basic`; wrong user and wrong password give the same 401."""
|
|
username, password = authhdr.parse_basic(request.headers.get("authorization"))
|
|
await reject_body(request)
|
|
found = await repo.get_credentials(db_of(request), username)
|
|
user, stored_hash = found if found else (None, None)
|
|
if not await passwords.verify_password(stored_hash, password) or user is None:
|
|
log.info("login_failed", extra={"fields": {"request_id": request.state.request_id}})
|
|
raise Unauthorized("Неверное имя пользователя или пароль", challenge=BASIC_CHALLENGE)
|
|
ttl = request.app.state.settings.session_ttl_seconds
|
|
token, expires_at = await sessions_of(request).create(user.id, ttl)
|
|
log.info("session_created", extra={"fields": {"request_id": request.state.request_id, "user_id": user.id}})
|
|
return ok({"token": token, "token_type": "Bearer", "expires_at": rfc3339(expires_at), "user": user.to_json()}, 201)
|
|
|
|
|
|
async def revoke_session(request: Request) -> Response:
|
|
token = authhdr.parse_bearer(request.headers.get("authorization"))
|
|
if not await sessions_of(request).revoke(token):
|
|
raise Unauthorized("Сессия недействительна, истекла или отозвана")
|
|
log.info("session_revoked", extra={"fields": {"request_id": request.state.request_id}})
|
|
return Response(status_code=204)
|
|
|
|
|
|
async def me(request: Request) -> JSONResponse:
|
|
user_id = await authenticate(request)
|
|
user = await repo.get_user(db_of(request), user_id)
|
|
if user is None:
|
|
raise Unauthorized("Сессия недействительна, истекла или отозвана")
|
|
return ok(user.to_json())
|
|
|
|
|
|
async def create_chat(request: Request) -> JSONResponse:
|
|
user_id = await authenticate(request)
|
|
data = await read_json(request)
|
|
validation.check_fields(data, {"title", "member_ids"})
|
|
title = validation.text_field(data, "title", 100)
|
|
member_ids = validation.member_ids_field(data)
|
|
chat = await repo.create_chat(db_of(request), user_id, title, member_ids)
|
|
log.info("chat_created", extra={"fields": {"request_id": request.state.request_id, "chat_id": chat.id, "members": len(member_ids)}})
|
|
return ok(chat.to_json(), 201)
|
|
|
|
|
|
async def list_chats(request: Request) -> JSONResponse:
|
|
user_id = await authenticate(request)
|
|
limit, raw_cursor = page_params(request)
|
|
after = cursor.decode(raw_cursor, cursor.CHATS, user_id) if raw_cursor else None
|
|
items, has_more = await repo.list_chats(db_of(request), user_id, after, limit)
|
|
next_cursor = cursor.encode(cursor.CHATS, user_id, items[-1].key) if has_more else None
|
|
return ok({"items": [c.to_json() for c in items], "next_cursor": next_cursor})
|
|
|
|
|
|
async def get_chat(request: Request) -> JSONResponse:
|
|
user_id = await authenticate(request)
|
|
chat_id = path_uuid(request, "chat_id")
|
|
return ok((await repo.get_chat(db_of(request), user_id, chat_id)).to_json())
|
|
|
|
|
|
def parse_message(data: dict[str, Any]) -> tuple[str, list[str]]:
|
|
"""`text` is required and a string (also with attachments); `attachment_ids`, if present, an
|
|
array of 0-10 unique UUIDs. "" or whitespace-only text is allowed only with attachments."""
|
|
validation.check_fields(data, {"text"}, frozenset({"attachment_ids"}))
|
|
attachment_ids = validation.attachment_ids_field(data)
|
|
text = validation.text_field(data, "text", 4000, min_len=0 if attachment_ids else 1,
|
|
allow_blank=bool(attachment_ids))
|
|
return text, attachment_ids
|
|
|
|
|
|
async def create_message(request: Request) -> JSONResponse:
|
|
"""Order of answers for both write paths: 401 -> 400 bad chat id -> 404 outsider -> 400 key/body
|
|
-> 409 other body with the same key -> 201 (new or replayed). sender_id comes from the session."""
|
|
user_id = await authenticate(request)
|
|
chat_id = path_uuid(request, "chat_id")
|
|
db = db_of(request)
|
|
settings = request.app.state.settings
|
|
if settings.message_write_path == "multi":
|
|
await repo.ensure_member(db, user_id, chat_id) # outsiders get 404 before key/body are looked at
|
|
key = idempotency_key(request)
|
|
text, attachment_ids = parse_message(await read_json(request))
|
|
result = await repo.post_message(db, user_id, chat_id, key, request_fingerprint(text, attachment_ids), text,
|
|
settings.idempotency_ttl_seconds, attachment_ids)
|
|
else:
|
|
try:
|
|
key = idempotency_key(request)
|
|
text, attachment_ids = parse_message(await read_json(request))
|
|
except ApiError:
|
|
# Rare error path only: an outsider must still get 404, not a hint about the body.
|
|
await repo.ensure_member(db, user_id, chat_id)
|
|
raise
|
|
# Membership check, key claim, chat clock and message: one SQL call, one transaction.
|
|
result = await repo.post_message_single_call(db, user_id, chat_id, key,
|
|
request_fingerprint(text, attachment_ids), text,
|
|
settings.idempotency_ttl_seconds, attachment_ids)
|
|
if result.replayed:
|
|
log.info("idempotent_replay", extra={"fields": {"request_id": request.state.request_id,
|
|
"message_id": result.message.id}})
|
|
return ok(result.message.to_json(), 201)
|
|
|
|
|
|
async def list_messages(request: Request) -> JSONResponse:
|
|
user_id = await authenticate(request)
|
|
chat_id = path_uuid(request, "chat_id")
|
|
db = db_of(request)
|
|
await repo.ensure_member(db, user_id, chat_id) # 404 for outsiders before cursor details leak
|
|
limit, raw_cursor = page_params(request)
|
|
after = cursor.decode(raw_cursor, cursor.MESSAGES, chat_id) if raw_cursor else None
|
|
items, has_more = await repo.list_messages(db, chat_id, after, limit)
|
|
next_cursor = cursor.encode(cursor.MESSAGES, chat_id, items[-1].key) if has_more else None
|
|
return ok({"items": [m.to_json() for m in items], "next_cursor": next_cursor})
|
|
|
|
|
|
# ------------------------------------------------------------------ attachments (lab 4)
|
|
def fault(request: Request, point: str) -> None:
|
|
"""Failure injection for the level 4 experiments (FAULT_POINTS, compose.faults.yaml only)."""
|
|
if point in request.app.state.settings.fault_points:
|
|
log.warning("fault_injected", extra={"fields": {"request_id": request.state.request_id, "point": point}})
|
|
raise Unavailable("Внедрённый отказ: " + point)
|
|
|
|
|
|
async def upload_attachment(request: Request) -> JSONResponse:
|
|
"""POST /chats/{chat_id}/attachments?filename=...: raw PNG/JPEG -> 201 ready (attachments.py)."""
|
|
settings: Settings = request.app.state.settings
|
|
reader = attachments.BodyReader(request)
|
|
try:
|
|
user_id = await authenticate(request)
|
|
chat_id = path_uuid(request, "chat_id")
|
|
db = db_of(request)
|
|
await repo.ensure_member(db, user_id, chat_id) # outsiders: 404 before anything about the body
|
|
filename = validation.filename_param(validation.query_items(request.scope["query_string"]))
|
|
declared = attachments.declared_type(request)
|
|
attachments.declared_length(request, settings.max_upload_bytes)
|
|
slots: asyncio.Semaphore = request.app.state.upload_slots
|
|
try:
|
|
await asyncio.wait_for(slots.acquire(), settings.upload_queue_timeout_seconds)
|
|
except asyncio.TimeoutError:
|
|
raise attachments.Busy("Слишком много одновременных загрузок, повторите позже") from None
|
|
try:
|
|
upload = await attachments.read_image(reader, settings, declared, request.app.state.verify_slots)
|
|
finally:
|
|
slots.release()
|
|
except ApiError:
|
|
# Early rejection: drop (not store) a bounded rest of the body so the client reads our error.
|
|
await reader.discard(settings.max_upload_bytes + (1 << 20), timeout=5.0)
|
|
raise
|
|
attachment_id = uuid.uuid4()
|
|
object_key = attachments.new_object_key()
|
|
storage = storage_of(request)
|
|
await attachments.create_intent(db, attachment_id, chat_id, user_id, filename, upload.info, len(upload.data),
|
|
upload.sha256, object_key)
|
|
await storage.put(object_key, upload.data, upload.info.content_type,
|
|
{"attachment-id": str(attachment_id), "sha256": upload.sha256.hex()})
|
|
fault(request, "after_s3_put")
|
|
attachment = await attachments.mark_ready(db, attachment_id)
|
|
if attachment is None:
|
|
raise Unavailable("Загрузка не завершена, повторите запрос")
|
|
fault(request, "after_ready_commit")
|
|
log.info("attachment_created", extra={"fields": {"request_id": request.state.request_id,
|
|
"attachment_id": attachment.id, "chat_id": chat_id,
|
|
"size": attachment.size_bytes, "type": attachment.content_type}})
|
|
return ok(attachment.to_json(), 201)
|
|
|
|
|
|
async def get_attachment(request: Request) -> JSONResponse:
|
|
user_id = await authenticate(request)
|
|
attachment_id = path_uuid(request, "attachment_id")
|
|
return ok((await attachments.get_visible(db_of(request), user_id, attachment_id)).to_json())
|
|
|
|
|
|
def content_disposition(filename: str) -> str:
|
|
"""RFC 6266/5987: ASCII fallback + UTF-8 name; the stored name itself is never interpreted."""
|
|
from urllib.parse import quote
|
|
fallback = "".join(c if 32 <= ord(c) < 127 and c not in '"\\%;' else "_" for c in filename)
|
|
return f"attachment; filename=\"{fallback}\"; filename*=UTF-8''{quote(filename, safe='')}"
|
|
|
|
|
|
async def download_attachment(request: Request) -> Response:
|
|
"""Original bytes through the authorized API: no redirect, no public S3 URL. Streamed from
|
|
S3 in 64 KiB chunks (memory per download does not depend on the file size)."""
|
|
user_id = await authenticate(request)
|
|
attachment_id = path_uuid(request, "attachment_id")
|
|
query = validation.query_items(request.scope["query_string"])
|
|
try:
|
|
validation.variant_param(query)
|
|
except validation.NotFoundVariant:
|
|
await attachments.get_visible(db_of(request), user_id, attachment_id) # 404 for outsiders first
|
|
raise NotFound("Такого варианта у вложения нет") from None
|
|
attachment = await attachments.get_visible(db_of(request), user_id, attachment_id)
|
|
if attachment.lost:
|
|
raise NotFound("Оригинал вложения утрачен")
|
|
try:
|
|
size, chunks = await storage_of(request).open_stream(attachment.object_key)
|
|
except ObjectMissing:
|
|
# A ready row without its object: data loss, reported by the reconciler (quarantine).
|
|
log.error("attachment_object_missing", extra={"fields": {"request_id": request.state.request_id,
|
|
"attachment_id": attachment.id}})
|
|
raise NotFound("Оригинал вложения утрачен") from None
|
|
if size != attachment.size_bytes:
|
|
log.error("attachment_size_mismatch", extra={"fields": {"request_id": request.state.request_id,
|
|
"attachment_id": attachment.id}})
|
|
await chunks.aclose()
|
|
raise Unavailable("Оригинал вложения временно недоступен")
|
|
headers = {
|
|
"Content-Length": str(size),
|
|
"Content-Disposition": content_disposition(attachment.filename),
|
|
"X-Content-Type-Options": "nosniff",
|
|
"Cache-Control": "private, no-store",
|
|
"ETag": '"' + attachment.sha256 + '"',
|
|
}
|
|
return StreamingResponse(chunks, media_type=attachment.content_type, headers=headers)
|
|
|
|
|
|
def create_app(settings: Settings | None = None) -> Starlette:
|
|
settings = settings or Settings.from_env()
|
|
db = Database(settings)
|
|
sessions = build_store(settings, db)
|
|
storage = Storage(settings)
|
|
|
|
async def purge_loop() -> None:
|
|
"""Housekeeping: expired Idempotency-Key rows (older than IDEMPOTENCY_TTL_SECONDS)."""
|
|
while True:
|
|
await asyncio.sleep(600)
|
|
try:
|
|
deleted = await repo.purge_idempotency_keys(db, settings.idempotency_ttl_seconds)
|
|
if deleted:
|
|
log.info("idempotency_keys_purged", extra={"fields": {"deleted": deleted}})
|
|
except ApiError:
|
|
pass # database unavailable right now; next round
|
|
|
|
async def janitor_loop(every: float) -> None:
|
|
"""Level 4 cleanup: intents of failed uploads older than PENDING_GRACE_SECONDS (attachments.py).
|
|
Every replica runs it; the advisory lock lets one round run at a time."""
|
|
while True:
|
|
await asyncio.sleep(every * (0.5 + random.random()))
|
|
try:
|
|
removed = await attachments.clean_stale_pending(db, storage, settings.pending_grace_seconds)
|
|
if removed:
|
|
log.info("stale_uploads_removed", extra={"fields": {"count": removed}})
|
|
except ApiError:
|
|
pass # PostgreSQL or S3 unavailable right now; the rows stay pending for the next round
|
|
|
|
stats_log = logging.getLogger("messenger.stats")
|
|
|
|
async def stats_loop(every: float) -> None:
|
|
"""Experiments only: DB pool saturation (waiting requests, wait time) and process CPU."""
|
|
cpu = time.process_time()
|
|
db.pool.pop_stats()
|
|
while True:
|
|
await asyncio.sleep(every)
|
|
stats = db.pool.pop_stats()
|
|
now_cpu = time.process_time()
|
|
stats_log.info("pool_stats", extra={"fields": {
|
|
"interval_s": every, "cpu_s": round(now_cpu - cpu, 4),
|
|
**{k: stats.get(k, 0) for k in ("pool_size", "pool_available", "requests_waiting", "requests_num",
|
|
"requests_queued", "requests_wait_ms", "usage_ms", "requests_errors")}}})
|
|
cpu = now_cpu
|
|
|
|
@contextlib.asynccontextmanager
|
|
async def lifespan(app: Starlette):
|
|
passwords.configure(settings.hash_concurrency)
|
|
await db.open()
|
|
await storage.open()
|
|
log.info("dependencies_configured", extra={"fields": {
|
|
"session_store": sessions.name, "session_ttl_s": settings.session_ttl_seconds,
|
|
"db_pool_max": settings.db_pool_max, "db_timeout_s": settings.db_timeout_seconds,
|
|
"instance_id": settings.instance_id, "drain_s": settings.drain_seconds,
|
|
"message_write_path": settings.message_write_path, "s3_bucket": settings.s3_bucket,
|
|
"upload_concurrency": settings.upload_concurrency, "verify_concurrency": settings.image_verify_concurrency,
|
|
"pending_grace_s": settings.pending_grace_seconds,
|
|
"fault_points": sorted(settings.fault_points)}})
|
|
tasks = [asyncio.create_task(purge_loop())]
|
|
if settings.janitor_interval_seconds > 0:
|
|
tasks.append(asyncio.create_task(janitor_loop(settings.janitor_interval_seconds)))
|
|
if settings.stats_log_seconds > 0:
|
|
tasks.append(asyncio.create_task(stats_loop(settings.stats_log_seconds)))
|
|
try:
|
|
yield
|
|
finally:
|
|
for task in tasks:
|
|
task.cancel()
|
|
await sessions.close()
|
|
await storage.close()
|
|
await db.close()
|
|
|
|
routes = [
|
|
Route("/health/live", live, methods=["GET"]),
|
|
Route("/health/ready", ready, methods=["GET"]),
|
|
Route("/health/ready/core", ready_core, methods=["GET"]),
|
|
Route("/api/v1/users", register_user, methods=["POST"]),
|
|
Route("/api/v1/users/me", me, methods=["GET"]),
|
|
Route("/api/v1/auth/sessions", create_session, methods=["POST"]),
|
|
Route("/api/v1/auth/sessions/current", revoke_session, methods=["DELETE"]),
|
|
Route("/api/v1/chats", create_chat, methods=["POST"]),
|
|
Route("/api/v1/chats", list_chats, methods=["GET"]),
|
|
Route("/api/v1/chats/{chat_id}", get_chat, methods=["GET"]),
|
|
Route("/api/v1/chats/{chat_id}/messages", create_message, methods=["POST"]),
|
|
Route("/api/v1/chats/{chat_id}/messages", list_messages, methods=["GET"]),
|
|
Route("/api/v1/chats/{chat_id}/attachments", upload_attachment, methods=["POST"]),
|
|
Route("/api/v1/attachments/{attachment_id}", get_attachment, methods=["GET"]),
|
|
Route("/api/v1/attachments/{attachment_id}/content", download_attachment, methods=["GET"]),
|
|
]
|
|
if settings.docs_enabled: # Swagger UI for manual experiments, not part of the contract
|
|
routes += [
|
|
Route("/docs", docs.swagger_page, methods=["GET"]),
|
|
Route("/openapi.json", docs.openapi_json, methods=["GET"]),
|
|
]
|
|
app = Starlette(
|
|
routes=routes,
|
|
exception_handlers={ApiError: api_error_handler, HTTPException: http_exception_handler},
|
|
lifespan=lifespan,
|
|
)
|
|
app.add_middleware(RequestContextMiddleware, instance_id=settings.instance_id)
|
|
app.state.settings = settings
|
|
app.state.db = db
|
|
app.state.sessions = sessions
|
|
app.state.storage = storage
|
|
app.state.upload_slots = asyncio.Semaphore(settings.upload_concurrency)
|
|
app.state.verify_slots = asyncio.Semaphore(settings.image_verify_concurrency)
|
|
app.state.draining = False
|
|
return app
|