forked from mtusi2026/mtusi2026lab4
Перенести рабочий стенд lab3 в репозиторий lab4.
API, Postgres, Redis и HAProxy остаются базой для вложений: сессии и история уже общие для нескольких реплик.
This commit is contained in:
+23
-7
@@ -3,18 +3,34 @@
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
LOG_LEVEL=info
|
||||
SHUTDOWN_GRACE_SECONDS=10
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
CACHE_TTL_SECONDS=60
|
||||
# Sessions live in Redis (lab2 grade 4 path carried from lab3). Not Postgres.
|
||||
SESSION_STORE=redis
|
||||
API_REPLICAS=2
|
||||
API_CPUS=0.50
|
||||
API_MEM=256m
|
||||
POSTGRES_CPUS=1.0
|
||||
POSTGRES_MEM=512m
|
||||
DB_POOL_MAX=4
|
||||
LB_DRAIN_SECONDS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
|
||||
# Compose interpolates these. Synthetic local values only; replace after copy.
|
||||
POSTGRES_PASSWORD=lab4-dev-only-change-me
|
||||
DATABASE_URL=postgresql://messenger:lab4-dev-only-change-me@postgres:5432/messenger
|
||||
REDIS_URL=redis://redis:6379/0
|
||||
|
||||
S3_ENDPOINT=http://s3:9000
|
||||
S3_REGION=us-east-1
|
||||
S3_BUCKET=messenger-attachments
|
||||
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
|
||||
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
|
||||
# Root is used only by bucket bootstrap. The API uses the app key below.
|
||||
MINIO_ROOT_USER=lab4-minio-root
|
||||
MINIO_ROOT_PASSWORD=lab4-dev-only-change-me
|
||||
S3_ACCESS_KEY_ID=lab4appkey00000001
|
||||
S3_SECRET_ACCESS_KEY=lab4-dev-only-change-me
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
ORPHAN_GRACE_SECONDS=120
|
||||
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
FROM python:3.12.8-slim-bookworm AS runtime
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
RUN groupadd --system app && useradd --system --gid app --home /app --shell /usr/sbin/nologin app \
|
||||
&& apt-get update \
|
||||
&& apt-get install -y --no-install-recommends curl \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY app ./app
|
||||
COPY migrations ./migrations
|
||||
COPY contracts/openapi.json ./contracts/openapi.json
|
||||
|
||||
USER app
|
||||
|
||||
ENV APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080 \
|
||||
APP_ENV=lab \
|
||||
PYTHONUNBUFFERED=1
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=12 \
|
||||
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"
|
||||
|
||||
CMD ["python", "-m", "app.main"]
|
||||
@@ -0,0 +1 @@
|
||||
"""Messenger API (lab 2): PostgreSQL source of truth, Redis sessions/cache."""
|
||||
+151
@@ -0,0 +1,151 @@
|
||||
import asyncio
|
||||
import json
|
||||
from collections.abc import Awaitable, Callable
|
||||
from typing import TypeVar
|
||||
|
||||
from app import config, rediscli
|
||||
from app.errors import AppError
|
||||
|
||||
T = TypeVar("T")
|
||||
CFG_SINGLEFLIGHT = "cfg:singleflight"
|
||||
CFG_INVALIDATE = "cfg:invalidate"
|
||||
CFG_DELAY_MS = "cfg:delay_ms"
|
||||
SQL_HISTORY = "metrics:sql:messages_select"
|
||||
|
||||
|
||||
class SingleFlight:
|
||||
def __init__(self) -> None:
|
||||
self._lock = asyncio.Lock()
|
||||
self._inflight: dict[str, asyncio.Task] = {}
|
||||
|
||||
async def do(self, key: str, factory: Callable[[], Awaitable[T]]) -> T:
|
||||
async with self._lock:
|
||||
task = self._inflight.get(key)
|
||||
if task is None:
|
||||
task = asyncio.create_task(factory())
|
||||
self._inflight[key] = task
|
||||
owner = True
|
||||
else:
|
||||
owner = False
|
||||
try:
|
||||
return await asyncio.shield(task)
|
||||
finally:
|
||||
if owner:
|
||||
async with self._lock:
|
||||
self._inflight.pop(key, None)
|
||||
|
||||
|
||||
_sf = SingleFlight()
|
||||
|
||||
|
||||
async def _flag(name: str, default: bool = True) -> bool:
|
||||
if not config.lab_mode():
|
||||
return default
|
||||
try:
|
||||
raw = await rediscli.require().get(name)
|
||||
except Exception:
|
||||
return default
|
||||
if raw is None:
|
||||
return default
|
||||
return raw not in {"0", "false", "off"}
|
||||
|
||||
|
||||
async def singleflight_enabled() -> bool:
|
||||
return await _flag(CFG_SINGLEFLIGHT, True)
|
||||
|
||||
|
||||
async def invalidate_enabled() -> bool:
|
||||
return await _flag(CFG_INVALIDATE, True)
|
||||
|
||||
|
||||
async def incr_history_sql() -> None:
|
||||
try:
|
||||
await rediscli.require().incr(SQL_HISTORY)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
async def history_sql_count() -> int:
|
||||
try:
|
||||
return int(await rediscli.require().get(SQL_HISTORY) or 0)
|
||||
except Exception:
|
||||
return 0
|
||||
|
||||
|
||||
async def reset_history_sql_count() -> None:
|
||||
try:
|
||||
await rediscli.require().set(SQL_HISTORY, 0)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
async def load_delay_seconds() -> float:
|
||||
if not config.lab_mode():
|
||||
return 0.0
|
||||
try:
|
||||
raw = await rediscli.require().get(CFG_DELAY_MS)
|
||||
except Exception:
|
||||
return 0.0
|
||||
try:
|
||||
return max(0.0, float(raw or 0) / 1000.0)
|
||||
except (TypeError, ValueError):
|
||||
return 0.0
|
||||
|
||||
|
||||
async def set_flags(
|
||||
*,
|
||||
singleflight: bool | None = None,
|
||||
invalidate: bool | None = None,
|
||||
delay_ms: int | None = None,
|
||||
) -> dict:
|
||||
r = rediscli.require()
|
||||
if singleflight is not None:
|
||||
await r.set(CFG_SINGLEFLIGHT, "1" if singleflight else "0")
|
||||
if invalidate is not None:
|
||||
await r.set(CFG_INVALIDATE, "1" if invalidate else "0")
|
||||
if delay_ms is not None:
|
||||
await r.set(CFG_DELAY_MS, str(int(delay_ms)))
|
||||
return {
|
||||
"singleflight": await singleflight_enabled(),
|
||||
"invalidate": await invalidate_enabled(),
|
||||
"history_sql": await history_sql_count(),
|
||||
"delay_ms": int((await load_delay_seconds()) * 1000),
|
||||
}
|
||||
|
||||
|
||||
async def get_history_page(chat_id: str, cursor: str, limit: int, loader: Callable[[], Awaitable[dict]]) -> dict:
|
||||
r = rediscli.require()
|
||||
try:
|
||||
version = await r.get("histver:" + chat_id) or "0"
|
||||
key = f"hist:{chat_id}:{version}:{cursor}:{limit}"
|
||||
cached = await r.get(key)
|
||||
if cached:
|
||||
return json.loads(cached)
|
||||
|
||||
async def load_and_store() -> dict:
|
||||
delay = await load_delay_seconds()
|
||||
if delay:
|
||||
await asyncio.sleep(delay)
|
||||
page = await loader()
|
||||
try:
|
||||
await r.set(key, json.dumps(page, ensure_ascii=False), ex=config.CACHE_TTL_SECONDS)
|
||||
except Exception:
|
||||
pass
|
||||
return page
|
||||
|
||||
if await singleflight_enabled():
|
||||
return await _sf.do(key, load_and_store)
|
||||
return await load_and_store()
|
||||
except AppError:
|
||||
raise
|
||||
except Exception:
|
||||
return await loader()
|
||||
|
||||
|
||||
async def invalidate_history(chat_id: str) -> None:
|
||||
if not await invalidate_enabled():
|
||||
return
|
||||
try:
|
||||
await rediscli.require().incr("histver:" + chat_id)
|
||||
except Exception:
|
||||
pass
|
||||
@@ -0,0 +1,42 @@
|
||||
import os
|
||||
import socket
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def _env(name: str, default: str = "") -> str:
|
||||
value = os.environ.get(name)
|
||||
return default if value is None or value == "" else value
|
||||
|
||||
|
||||
def _file_or_env(name: str, default: str = "") -> str:
|
||||
path = os.environ.get(name + "_FILE")
|
||||
if path:
|
||||
return Path(path).read_text(encoding="utf-8").strip()
|
||||
return _env(name, default)
|
||||
|
||||
|
||||
HOST = _env("APP_HOST", "0.0.0.0")
|
||||
PORT = int(_env("APP_PORT", "8080"))
|
||||
ENV = _env("APP_ENV", "lab")
|
||||
LOG_LEVEL = _env("LOG_LEVEL", "info").lower()
|
||||
SHUTDOWN_GRACE_SECONDS = float(_env("SHUTDOWN_GRACE_SECONDS", "10"))
|
||||
SESSION_TTL_SECONDS = int(_env("SESSION_TTL_SECONDS", "3600"))
|
||||
CACHE_TTL_SECONDS = int(_env("CACHE_TTL_SECONDS", "60"))
|
||||
DATABASE_URL = _file_or_env("DATABASE_URL")
|
||||
REDIS_URL = _file_or_env("REDIS_URL", "redis://redis:6379/0")
|
||||
SESSION_STORE = _env("SESSION_STORE", "redis")
|
||||
DB_POOL_MIN = int(_env("DB_POOL_MIN", "1"))
|
||||
DB_POOL_MAX = int(_env("DB_POOL_MAX", "10"))
|
||||
DB_COMMAND_TIMEOUT = float(_env("DB_COMMAND_TIMEOUT", "5"))
|
||||
DB_CONNECT_TIMEOUT = float(_env("DB_CONNECT_TIMEOUT", "5"))
|
||||
REDIS_SOCKET_TIMEOUT = float(_env("REDIS_SOCKET_TIMEOUT", "2"))
|
||||
IDEMPOTENCY_TTL_SECONDS = int(_env("IDEMPOTENCY_TTL_SECONDS", "86400"))
|
||||
MIGRATIONS_ON_START = _env("MIGRATIONS_ON_START", "1") == "1"
|
||||
LB_DRAIN_SECONDS = float(_env("LB_DRAIN_SECONDS", "2"))
|
||||
# Stable for the life of this process. Compose leaves it unset so each
|
||||
# container uses its own hostname; stop-one.sh maps that value to one replica.
|
||||
INSTANCE_ID = _env("INSTANCE_ID", socket.gethostname())
|
||||
|
||||
|
||||
def lab_mode() -> bool:
|
||||
return ENV == "lab"
|
||||
@@ -0,0 +1,112 @@
|
||||
import base64
|
||||
|
||||
import json
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
from typing import Any
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def encode_cursor(chat_id: str, created_at: str, entity_id: str) -> str:
|
||||
|
||||
payload = json.dumps({"c": chat_id, "t": created_at, "i": entity_id}, separators=(",", ":"))
|
||||
|
||||
return base64.urlsafe_b64encode(payload.encode("utf-8")).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def _validate_cursor_timestamp(value: str) -> None:
|
||||
|
||||
if not value.endswith("Z"):
|
||||
|
||||
raise ValueError("invalid cursor timestamp")
|
||||
|
||||
try:
|
||||
|
||||
datetime.fromisoformat(value[:-1] + "+00:00")
|
||||
|
||||
except ValueError as exc:
|
||||
|
||||
raise ValueError("invalid cursor timestamp") from exc
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def _require_str_field(data: dict, key: str) -> str:
|
||||
|
||||
if key not in data:
|
||||
|
||||
raise ValueError("invalid cursor")
|
||||
|
||||
value = data[key]
|
||||
|
||||
if not isinstance(value, str):
|
||||
|
||||
raise ValueError("invalid cursor")
|
||||
|
||||
return value
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def decode_cursor(cursor: str, expected_chat_id: str) -> tuple[str, str]:
|
||||
|
||||
pad = "=" * (-len(cursor) % 4)
|
||||
|
||||
try:
|
||||
|
||||
raw = base64.urlsafe_b64decode((cursor + pad).encode("ascii"))
|
||||
|
||||
data: Any = json.loads(raw.decode("utf-8"))
|
||||
|
||||
except (ValueError, json.JSONDecodeError, UnicodeDecodeError) as exc:
|
||||
|
||||
raise ValueError("invalid cursor") from exc
|
||||
|
||||
if not isinstance(data, dict):
|
||||
|
||||
raise ValueError("invalid cursor")
|
||||
|
||||
try:
|
||||
|
||||
chat_id = _require_str_field(data, "c")
|
||||
|
||||
created_at = _require_str_field(data, "t")
|
||||
|
||||
entity_id = _require_str_field(data, "i")
|
||||
|
||||
except ValueError as exc:
|
||||
|
||||
raise ValueError("invalid cursor") from exc
|
||||
|
||||
if chat_id != expected_chat_id:
|
||||
|
||||
raise ValueError("cursor chat mismatch")
|
||||
|
||||
try:
|
||||
|
||||
UUID(entity_id)
|
||||
|
||||
except ValueError as exc:
|
||||
|
||||
raise ValueError("invalid cursor") from exc
|
||||
|
||||
try:
|
||||
|
||||
_validate_cursor_timestamp(created_at)
|
||||
|
||||
except ValueError as exc:
|
||||
|
||||
raise ValueError("invalid cursor") from exc
|
||||
|
||||
return created_at, entity_id
|
||||
|
||||
@@ -0,0 +1,87 @@
|
||||
from pathlib import Path
|
||||
|
||||
import asyncpg
|
||||
|
||||
from app import config
|
||||
from app.errors import AppError
|
||||
|
||||
pool: asyncpg.Pool | None = None
|
||||
INTEGRITY = (
|
||||
asyncpg.UniqueViolationError,
|
||||
asyncpg.ForeignKeyViolationError,
|
||||
asyncpg.CheckViolationError,
|
||||
)
|
||||
|
||||
|
||||
def _migrations_dir() -> Path:
|
||||
here = Path(__file__).resolve().parent
|
||||
for candidate in (here.parent / "migrations", Path("/app/migrations")):
|
||||
if candidate.is_dir():
|
||||
return candidate
|
||||
raise RuntimeError("migrations directory not found")
|
||||
|
||||
|
||||
async def connect() -> asyncpg.Pool:
|
||||
global pool
|
||||
if not config.DATABASE_URL:
|
||||
raise RuntimeError("DATABASE_URL is not set")
|
||||
pool = await asyncpg.create_pool(
|
||||
dsn=config.DATABASE_URL,
|
||||
min_size=config.DB_POOL_MIN,
|
||||
max_size=config.DB_POOL_MAX,
|
||||
command_timeout=config.DB_COMMAND_TIMEOUT,
|
||||
timeout=config.DB_CONNECT_TIMEOUT,
|
||||
)
|
||||
return pool
|
||||
|
||||
|
||||
async def close() -> None:
|
||||
global pool
|
||||
if pool is not None:
|
||||
await pool.close()
|
||||
pool = None
|
||||
|
||||
|
||||
def require() -> asyncpg.Pool:
|
||||
if pool is None:
|
||||
raise AppError(503, "service unavailable")
|
||||
return pool
|
||||
|
||||
|
||||
async def ping() -> None:
|
||||
try:
|
||||
async with require().acquire() as conn:
|
||||
await conn.execute("SELECT 1")
|
||||
except AppError:
|
||||
raise
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
|
||||
|
||||
_MIGRATION_LOCK = 87133103
|
||||
|
||||
|
||||
async def apply_migrations() -> None:
|
||||
"""Apply pending SQL files once. A session advisory lock stops replica races."""
|
||||
directory = _migrations_dir()
|
||||
async with require().acquire() as conn:
|
||||
await conn.execute("SELECT pg_advisory_lock($1)", _MIGRATION_LOCK)
|
||||
try:
|
||||
await conn.execute(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
filename TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
)
|
||||
"""
|
||||
)
|
||||
applied = {row["filename"] for row in await conn.fetch("SELECT filename FROM schema_migrations")}
|
||||
for path in sorted(p for p in directory.glob("*.sql") if p.is_file()):
|
||||
if path.name in applied:
|
||||
continue
|
||||
sql = path.read_text(encoding="utf-8")
|
||||
async with conn.transaction():
|
||||
await conn.execute(sql)
|
||||
await conn.execute("INSERT INTO schema_migrations(filename) VALUES($1)", path.name)
|
||||
finally:
|
||||
await conn.execute("SELECT pg_advisory_unlock($1)", _MIGRATION_LOCK)
|
||||
+52
@@ -0,0 +1,52 @@
|
||||
import json
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import HTMLResponse, JSONResponse, Response
|
||||
|
||||
_SPEC_CANDIDATES = (
|
||||
Path(__file__).resolve().parents[1] / "contracts" / "openapi.json",
|
||||
Path("/app/contracts/openapi.json"),
|
||||
)
|
||||
|
||||
_SWAGGER_HTML = """<!DOCTYPE html>
|
||||
<html lang="ru">
|
||||
<head>
|
||||
<meta charset="utf-8"/>
|
||||
<title>MTUSI Messenger — Swagger (lab2)</title>
|
||||
<link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui.css"/>
|
||||
</head>
|
||||
<body>
|
||||
<div id="swagger-ui"></div>
|
||||
<script src="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui-bundle.js"></script>
|
||||
<script>
|
||||
window.onload = function () {
|
||||
SwaggerUIBundle({
|
||||
url: "/openapi.json",
|
||||
dom_id: "#swagger-ui",
|
||||
deepLinking: true,
|
||||
persistAuthorization: true,
|
||||
tryItOutEnabled: true
|
||||
});
|
||||
};
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
"""
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def _load_spec() -> dict:
|
||||
for path in _SPEC_CANDIDATES:
|
||||
if path.is_file():
|
||||
return json.loads(path.read_text(encoding="utf-8"))
|
||||
return {"openapi": "3.1.0", "info": {"title": "MTUSI Messenger", "version": "1.2.0"}, "paths": {}}
|
||||
|
||||
|
||||
async def openapi_json(_: Request) -> Response:
|
||||
return JSONResponse(_load_spec())
|
||||
|
||||
|
||||
async def swagger_ui(_: Request) -> Response:
|
||||
return HTMLResponse(_SWAGGER_HTML)
|
||||
@@ -0,0 +1,49 @@
|
||||
from typing import Dict, Optional
|
||||
|
||||
from starlette.responses import JSONResponse
|
||||
|
||||
|
||||
ERROR_CODES = {
|
||||
400: "invalid_request",
|
||||
401: "unauthorized",
|
||||
404: "not_found",
|
||||
409: "conflict",
|
||||
413: "payload_too_large",
|
||||
415: "unsupported_media_type",
|
||||
429: "rate_limited",
|
||||
503: "unavailable",
|
||||
500: "internal_error",
|
||||
}
|
||||
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
class AppError(Exception):
|
||||
def __init__(self, status: int, message: str, www_authenticate: str | None = None) -> None:
|
||||
super().__init__(message)
|
||||
self.status = status
|
||||
self.message = message
|
||||
self.www_authenticate = www_authenticate
|
||||
|
||||
|
||||
def error_response(
|
||||
status: int,
|
||||
message: str,
|
||||
request_id: str,
|
||||
extra_headers: Optional[Dict[str, str]] = None,
|
||||
) -> JSONResponse:
|
||||
code = ERROR_CODES.get(status, "internal_error")
|
||||
headers = {"X-Request-Id": request_id, "Content-Type": "application/json"}
|
||||
if extra_headers:
|
||||
headers.update(extra_headers)
|
||||
return JSONResponse(
|
||||
status_code=status,
|
||||
headers=headers,
|
||||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
)
|
||||
|
||||
|
||||
def from_app_error(exc: AppError, request_id: str) -> JSONResponse:
|
||||
extra = {"WWW-Authenticate": exc.www_authenticate} if exc.www_authenticate else None
|
||||
return error_response(exc.status, exc.message, request_id, extra)
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
import asyncio
|
||||
import logging
|
||||
import signal
|
||||
import sys
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
import uvicorn
|
||||
from starlette.applications import Starlette
|
||||
from starlette.exceptions import HTTPException
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response
|
||||
from starlette.routing import Route
|
||||
|
||||
from app import config, db, rediscli
|
||||
from app.docs import openapi_json, swagger_ui
|
||||
from app.errors import AppError, error_response, from_app_error
|
||||
from app.middleware import RequestContextMiddleware
|
||||
from app.routes import (
|
||||
create_chat,
|
||||
create_message,
|
||||
create_session,
|
||||
current_user,
|
||||
get_chat,
|
||||
health_live,
|
||||
health_ready,
|
||||
lab_flags,
|
||||
lab_metrics,
|
||||
list_chats,
|
||||
list_messages,
|
||||
register_user,
|
||||
revoke_session,
|
||||
)
|
||||
|
||||
|
||||
def _request_id(request: Request) -> str:
|
||||
existing = getattr(request.state, "request_id", None)
|
||||
if existing:
|
||||
return existing
|
||||
return request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
|
||||
|
||||
async def not_found_handler(request: Request, exc: HTTPException) -> Response:
|
||||
return error_response(404, "not found", _request_id(request))
|
||||
|
||||
|
||||
async def app_error_handler(request: Request, exc: AppError) -> Response:
|
||||
return from_app_error(exc, _request_id(request))
|
||||
|
||||
|
||||
def publish_instance_id() -> None:
|
||||
path = Path(config._env("INSTANCE_ID_FILE", "/tmp/instance-id"))
|
||||
try:
|
||||
path.write_text(config.INSTANCE_ID, encoding="utf-8")
|
||||
except OSError:
|
||||
logging.getLogger("messenger").warning("instance id file was not written")
|
||||
|
||||
|
||||
async def startup() -> None:
|
||||
publish_instance_id()
|
||||
logging.getLogger("messenger").info("instance_id=%s", config.INSTANCE_ID)
|
||||
await db.connect()
|
||||
if config.MIGRATIONS_ON_START:
|
||||
await db.apply_migrations()
|
||||
await rediscli.connect()
|
||||
|
||||
|
||||
async def shutdown() -> None:
|
||||
await rediscli.close()
|
||||
await db.close()
|
||||
|
||||
|
||||
def build_app() -> Starlette:
|
||||
app = Starlette(
|
||||
routes=[
|
||||
Route("/docs", swagger_ui, methods=["GET"]),
|
||||
Route("/openapi.json", openapi_json, methods=["GET"]),
|
||||
Route("/health/live", health_live, methods=["GET"]),
|
||||
Route("/health/ready", health_ready, methods=["GET"]),
|
||||
Route("/api/v1/users", register_user, methods=["POST"]),
|
||||
Route("/api/v1/users/me", current_user, 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/_lab/metrics", lab_metrics, methods=["GET"]),
|
||||
Route("/api/v1/_lab/flags", lab_flags, methods=["POST"]),
|
||||
],
|
||||
exception_handlers={404: not_found_handler, AppError: app_error_handler},
|
||||
on_startup=[startup],
|
||||
on_shutdown=[shutdown],
|
||||
)
|
||||
app.state.shutting_down = False
|
||||
app.add_middleware(RequestContextMiddleware)
|
||||
return app
|
||||
|
||||
|
||||
def configure_logging() -> None:
|
||||
logging.basicConfig(
|
||||
level=getattr(logging, config.LOG_LEVEL.upper(), logging.INFO),
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
stream=sys.stdout,
|
||||
)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
configure_logging()
|
||||
app = build_app()
|
||||
loop = asyncio.new_event_loop()
|
||||
asyncio.set_event_loop(loop)
|
||||
|
||||
server = uvicorn.Server(
|
||||
uvicorn.Config(
|
||||
app,
|
||||
host=config.HOST,
|
||||
port=config.PORT,
|
||||
log_level=config.LOG_LEVEL,
|
||||
access_log=False,
|
||||
timeout_graceful_shutdown=int(config.SHUTDOWN_GRACE_SECONDS),
|
||||
)
|
||||
)
|
||||
|
||||
def _begin_shutdown() -> None:
|
||||
if app.state.shutting_down:
|
||||
return
|
||||
logging.getLogger("messenger").info(
|
||||
"shutdown signal received; readiness fails now, exit in %.1fs",
|
||||
config.LB_DRAIN_SECONDS,
|
||||
)
|
||||
app.state.shutting_down = True
|
||||
loop.call_later(config.LB_DRAIN_SECONDS, lambda: setattr(server, "should_exit", True))
|
||||
|
||||
for sig in (signal.SIGTERM, signal.SIGINT):
|
||||
try:
|
||||
loop.add_signal_handler(sig, _begin_shutdown)
|
||||
except NotImplementedError:
|
||||
signal.signal(sig, lambda *_: _begin_shutdown())
|
||||
|
||||
loop.run_until_complete(server.serve())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,48 @@
|
||||
import logging
|
||||
import time
|
||||
import uuid
|
||||
from typing import Callable
|
||||
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response
|
||||
|
||||
from app.config import INSTANCE_ID
|
||||
from app.errors import AppError, error_response, from_app_error
|
||||
|
||||
logger = logging.getLogger("messenger.access")
|
||||
|
||||
|
||||
def _stamp(response: Response, request_id: str) -> Response:
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
response.headers["X-Instance-Id"] = INSTANCE_ID
|
||||
return response
|
||||
|
||||
|
||||
class RequestContextMiddleware(BaseHTTPMiddleware):
|
||||
async def dispatch(self, request: Request, call_next: Callable) -> Response:
|
||||
request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
request.state.request_id = request_id
|
||||
|
||||
if request.app.state.shutting_down and request.url.path not in ("/health/live", "/health/ready"):
|
||||
return _stamp(error_response(503, "service is shutting down", request_id), request_id)
|
||||
|
||||
started = time.perf_counter()
|
||||
try:
|
||||
response = await call_next(request)
|
||||
except AppError as exc:
|
||||
return _stamp(from_app_error(exc, request_id), request_id)
|
||||
except Exception:
|
||||
logger.exception("request_id=%s unhandled error path=%s", request_id, request.url.path)
|
||||
return _stamp(error_response(500, "internal error", request_id), request_id)
|
||||
elapsed_ms = (time.perf_counter() - started) * 1000
|
||||
_stamp(response, request_id)
|
||||
logger.info(
|
||||
"request_id=%s method=%s path=%s status=%s duration_ms=%.2f",
|
||||
request_id,
|
||||
request.method,
|
||||
request.url.path,
|
||||
response.status_code,
|
||||
elapsed_ms,
|
||||
)
|
||||
return response
|
||||
@@ -0,0 +1,29 @@
|
||||
"""One-shot schema apply. API replicas do not run this on startup."""
|
||||
import asyncio
|
||||
import logging
|
||||
import sys
|
||||
|
||||
from app import config, db
|
||||
|
||||
|
||||
async def _main() -> None:
|
||||
if not config.DATABASE_URL:
|
||||
raise SystemExit("DATABASE_URL is not set")
|
||||
await db.connect()
|
||||
try:
|
||||
await db.apply_migrations()
|
||||
finally:
|
||||
await db.close()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
logging.basicConfig(
|
||||
level=getattr(logging, config.LOG_LEVEL.upper(), logging.INFO),
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
stream=sys.stdout,
|
||||
)
|
||||
asyncio.run(_main())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,23 @@
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import InvalidHashError, VerifyMismatchError
|
||||
|
||||
hasher = PasswordHasher(time_cost=2, memory_cost=8192, parallelism=1)
|
||||
_dummy = None
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
return hasher.hash(password)
|
||||
|
||||
|
||||
def dummy_hash() -> str:
|
||||
global _dummy
|
||||
if _dummy is None:
|
||||
_dummy = hash_password("timing-dummy-password")
|
||||
return _dummy
|
||||
|
||||
|
||||
def verify_password(password_hash: str, password: str) -> bool:
|
||||
try:
|
||||
return hasher.verify(password_hash, password)
|
||||
except (VerifyMismatchError, InvalidHashError, TypeError, ValueError):
|
||||
return False
|
||||
@@ -0,0 +1,40 @@
|
||||
import redis.asyncio as redis
|
||||
|
||||
from app import config
|
||||
from app.errors import AppError
|
||||
|
||||
client: redis.Redis | None = None
|
||||
|
||||
|
||||
async def connect() -> redis.Redis:
|
||||
global client
|
||||
client = redis.from_url(
|
||||
config.REDIS_URL,
|
||||
socket_connect_timeout=config.REDIS_SOCKET_TIMEOUT,
|
||||
socket_timeout=config.REDIS_SOCKET_TIMEOUT,
|
||||
decode_responses=True,
|
||||
)
|
||||
await client.ping()
|
||||
return client
|
||||
|
||||
|
||||
async def close() -> None:
|
||||
global client
|
||||
if client is not None:
|
||||
await client.close()
|
||||
client = None
|
||||
|
||||
|
||||
def require() -> redis.Redis:
|
||||
if client is None:
|
||||
raise AppError(503, "service unavailable")
|
||||
return client
|
||||
|
||||
|
||||
async def ping() -> None:
|
||||
try:
|
||||
await require().ping()
|
||||
except AppError:
|
||||
raise
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
+284
@@ -0,0 +1,284 @@
|
||||
import base64
|
||||
import binascii
|
||||
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import JSONResponse, Response
|
||||
|
||||
from app import cache, config, db, rediscli, sessions, store
|
||||
from app.cursor_codec import decode_cursor, encode_cursor
|
||||
from app.errors import BASIC_CHALLENGE, BEARER_CHALLENGE, AppError, error_response
|
||||
from app.passwords import dummy_hash, hash_password, verify_password
|
||||
from app.validation import (
|
||||
parse_json_body,
|
||||
require_exact_keys,
|
||||
validate_display_name,
|
||||
validate_limit,
|
||||
validate_idempotency_key,
|
||||
validate_message_text,
|
||||
validate_password,
|
||||
validate_title,
|
||||
validate_username,
|
||||
validate_uuid,
|
||||
)
|
||||
|
||||
|
||||
def _json(data: dict, request_id: str, status: int = 200) -> JSONResponse:
|
||||
return JSONResponse(status_code=status, headers={"X-Request-Id": request_id}, content=data)
|
||||
|
||||
|
||||
def _empty(request_id: str) -> Response:
|
||||
return Response(status_code=204, headers={"X-Request-Id": request_id})
|
||||
|
||||
|
||||
async def _bearer_user(request: Request) -> dict:
|
||||
header = request.headers.get("Authorization") or ""
|
||||
scheme, _, rest = header.partition(" ")
|
||||
if scheme.lower() != "bearer" or not rest.strip():
|
||||
raise AppError(401, "authentication required", BEARER_CHALLENGE)
|
||||
user_id = str(await sessions.resolve(rest.strip()))
|
||||
user = await store.get_user(user_id)
|
||||
if user is None:
|
||||
raise AppError(401, "authentication required", BEARER_CHALLENGE)
|
||||
return user
|
||||
|
||||
|
||||
async def health_live(request: Request) -> Response:
|
||||
return _json({"status": "ok"}, request.state.request_id)
|
||||
|
||||
|
||||
async def health_ready(request: Request) -> Response:
|
||||
rid = request.state.request_id
|
||||
if request.app.state.shutting_down:
|
||||
return error_response(503, "service is shutting down", rid)
|
||||
await db.ping()
|
||||
await rediscli.ping()
|
||||
return _json({"status": "ok"}, rid)
|
||||
|
||||
|
||||
async def register_user(request: Request) -> Response:
|
||||
rid = request.state.request_id
|
||||
if request.headers.get("content-type", "").split(";")[0].strip().lower() not in ("application/json", ""):
|
||||
if request.headers.get("content-type"):
|
||||
return error_response(415, "unsupported media type", rid)
|
||||
raw = await request.body()
|
||||
body, err = parse_json_body(raw)
|
||||
if err:
|
||||
return error_response(400, err, rid)
|
||||
assert body is not None
|
||||
if require_exact_keys(body, {"username", "display_name", "password"}, {"username", "display_name", "password"}):
|
||||
return error_response(400, "invalid user payload", rid)
|
||||
if validate_username(body["username"]) or validate_display_name(body["display_name"]) or validate_password(body["password"]):
|
||||
return error_response(400, "invalid user fields", rid)
|
||||
user, conflict = await store.create_user(body["username"], body["display_name"], hash_password(body["password"]))
|
||||
if conflict:
|
||||
return error_response(409, "username already taken", rid)
|
||||
assert user is not None
|
||||
return _json(user, rid, 201)
|
||||
|
||||
|
||||
async def current_user(request: Request) -> Response:
|
||||
user = await _bearer_user(request)
|
||||
return _json(user, request.state.request_id)
|
||||
|
||||
|
||||
async def create_session(request: Request) -> Response:
|
||||
rid = request.state.request_id
|
||||
header = request.headers.get("Authorization") or ""
|
||||
scheme, _, rest = header.partition(" ")
|
||||
if scheme.lower() != "basic" or not rest.strip():
|
||||
return error_response(401, "authentication required", rid, {"WWW-Authenticate": BASIC_CHALLENGE})
|
||||
try:
|
||||
decoded = base64.b64decode(rest.strip(), validate=True).decode("utf-8")
|
||||
except (binascii.Error, UnicodeError, ValueError):
|
||||
return error_response(401, "authentication required", rid, {"WWW-Authenticate": BASIC_CHALLENGE})
|
||||
username, sep, password = decoded.partition(":")
|
||||
if not sep:
|
||||
return error_response(401, "authentication required", rid, {"WWW-Authenticate": BASIC_CHALLENGE})
|
||||
row = await store.get_user_by_username(username)
|
||||
password_hash = row["password_hash"] if row else dummy_hash()
|
||||
if row is None or not verify_password(password_hash, password):
|
||||
return error_response(401, "authentication required", rid, {"WWW-Authenticate": BASIC_CHALLENGE})
|
||||
token, expires_at = await sessions.create(row["id"])
|
||||
return _json(
|
||||
{
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": expires_at,
|
||||
"user": store.user_dict(row),
|
||||
},
|
||||
rid,
|
||||
201,
|
||||
)
|
||||
|
||||
|
||||
async def revoke_session(request: Request) -> Response:
|
||||
header = request.headers.get("Authorization") or ""
|
||||
scheme, _, rest = header.partition(" ")
|
||||
if scheme.lower() != "bearer" or not rest.strip():
|
||||
raise AppError(401, "authentication required", BEARER_CHALLENGE)
|
||||
await sessions.revoke(rest.strip())
|
||||
return _empty(request.state.request_id)
|
||||
|
||||
|
||||
async def create_chat(request: Request) -> Response:
|
||||
rid = request.state.request_id
|
||||
user = await _bearer_user(request)
|
||||
ct = request.headers.get("content-type", "").split(";")[0].strip().lower()
|
||||
if ct and ct != "application/json":
|
||||
return error_response(415, "unsupported media type", rid)
|
||||
raw = await request.body()
|
||||
body, err = parse_json_body(raw)
|
||||
if err:
|
||||
return error_response(400, err, rid)
|
||||
assert body is not None
|
||||
if require_exact_keys(body, {"title", "member_ids"}, {"title", "member_ids"}):
|
||||
return error_response(400, "invalid chat payload", rid)
|
||||
if validate_title(body["title"]):
|
||||
return error_response(400, "invalid title", rid)
|
||||
members = body["member_ids"]
|
||||
if not isinstance(members, list) or not members:
|
||||
return error_response(400, "invalid member_ids", rid)
|
||||
if len(members) > 100:
|
||||
return error_response(400, "too many members", rid)
|
||||
for mid in members:
|
||||
if validate_uuid(mid):
|
||||
return error_response(400, "invalid member id", rid)
|
||||
chat, create_err = await store.create_chat(body["title"], members, user["id"])
|
||||
if create_err == "caller not in members":
|
||||
return error_response(400, "caller must be a member", rid)
|
||||
if create_err in ("duplicate members", "unknown member"):
|
||||
return error_response(400, "invalid members", rid)
|
||||
assert chat is not None
|
||||
return _json(chat, rid, 201)
|
||||
|
||||
|
||||
async def list_chats(request: Request) -> Response:
|
||||
rid = request.state.request_id
|
||||
user = await _bearer_user(request)
|
||||
limit, limit_err = validate_limit(request.query_params.get("limit"))
|
||||
if limit_err:
|
||||
return error_response(400, limit_err, rid)
|
||||
assert limit is not None
|
||||
cursor_raw = request.query_params.get("cursor")
|
||||
after = None
|
||||
if cursor_raw is not None:
|
||||
if not cursor_raw.strip():
|
||||
return error_response(400, "invalid cursor", rid)
|
||||
try:
|
||||
created_at, entity_id = decode_cursor(cursor_raw, user["id"])
|
||||
except ValueError:
|
||||
return error_response(400, "invalid cursor", rid)
|
||||
after = (created_at, entity_id)
|
||||
items, next_key = await store.list_chats(user["id"], limit, after)
|
||||
next_cursor = None
|
||||
if next_key is not None:
|
||||
next_cursor = encode_cursor(user["id"], next_key[0], next_key[1])
|
||||
return _json({"items": items, "next_cursor": next_cursor}, rid)
|
||||
|
||||
|
||||
async def get_chat(request: Request) -> Response:
|
||||
rid = request.state.request_id
|
||||
user = await _bearer_user(request)
|
||||
chat_id = request.path_params["chat_id"]
|
||||
if validate_uuid(chat_id):
|
||||
return error_response(400, "invalid chat id", rid)
|
||||
chat = await store.get_chat(chat_id, user["id"])
|
||||
if chat is None:
|
||||
return error_response(404, "chat not found", rid)
|
||||
return _json(chat, rid)
|
||||
|
||||
|
||||
async def create_message(request: Request) -> Response:
|
||||
rid = request.state.request_id
|
||||
user = await _bearer_user(request)
|
||||
chat_id = request.path_params["chat_id"]
|
||||
if validate_uuid(chat_id):
|
||||
return error_response(400, "invalid chat id", rid)
|
||||
ct = request.headers.get("content-type", "").split(";")[0].strip().lower()
|
||||
if ct and ct != "application/json":
|
||||
return error_response(415, "unsupported media type", rid)
|
||||
raw = await request.body()
|
||||
body, err = parse_json_body(raw)
|
||||
if err:
|
||||
return error_response(400, err, rid)
|
||||
assert body is not None
|
||||
if require_exact_keys(body, {"text"}, {"text"}):
|
||||
return error_response(400, "invalid message payload", rid)
|
||||
if validate_message_text(body["text"]):
|
||||
return error_response(400, "invalid message text", rid)
|
||||
if validate_idempotency_key(request.headers.get("Idempotency-Key")):
|
||||
return error_response(400, "invalid idempotency key", rid)
|
||||
message, msg_err = await store.add_message(
|
||||
chat_id,
|
||||
user["id"],
|
||||
body["text"],
|
||||
request.headers.get("Idempotency-Key") or "",
|
||||
request.url.path,
|
||||
)
|
||||
if msg_err == "not_found":
|
||||
return error_response(404, "chat not found", rid)
|
||||
if msg_err == "conflict":
|
||||
return error_response(409, "idempotency key reused with a different body", rid)
|
||||
assert message is not None
|
||||
return _json(message, rid, 201)
|
||||
|
||||
|
||||
async def list_messages(request: Request) -> Response:
|
||||
rid = request.state.request_id
|
||||
user = await _bearer_user(request)
|
||||
chat_id = request.path_params["chat_id"]
|
||||
if validate_uuid(chat_id):
|
||||
return error_response(400, "invalid chat id", rid)
|
||||
limit, limit_err = validate_limit(request.query_params.get("limit"))
|
||||
if limit_err:
|
||||
return error_response(400, limit_err, rid)
|
||||
assert limit is not None
|
||||
cursor_raw = request.query_params.get("cursor")
|
||||
after = None
|
||||
if cursor_raw is not None:
|
||||
if not cursor_raw.strip():
|
||||
return error_response(400, "invalid cursor", rid)
|
||||
try:
|
||||
created_at, entity_id = decode_cursor(cursor_raw, chat_id)
|
||||
except ValueError:
|
||||
return error_response(400, "invalid cursor", rid)
|
||||
after = (created_at, entity_id)
|
||||
page, next_key, list_err = await store.list_messages(chat_id, user["id"], limit, after)
|
||||
if list_err == "not_found":
|
||||
return error_response(404, "chat not found", rid)
|
||||
assert page is not None
|
||||
next_cursor = None
|
||||
if next_key is not None:
|
||||
next_cursor = encode_cursor(chat_id, next_key[0], next_key[1])
|
||||
return _json({"items": page, "next_cursor": next_cursor}, rid)
|
||||
|
||||
|
||||
async def lab_metrics(request: Request) -> Response:
|
||||
if not config.lab_mode():
|
||||
return error_response(404, "not found", request.state.request_id)
|
||||
return _json(
|
||||
{
|
||||
"singleflight": await cache.singleflight_enabled(),
|
||||
"invalidate": await cache.invalidate_enabled(),
|
||||
"history_sql": await cache.history_sql_count(),
|
||||
},
|
||||
request.state.request_id,
|
||||
)
|
||||
|
||||
|
||||
async def lab_flags(request: Request) -> Response:
|
||||
if not config.lab_mode():
|
||||
return error_response(404, "not found", request.state.request_id)
|
||||
raw = await request.body()
|
||||
body, err = parse_json_body(raw)
|
||||
if err:
|
||||
return error_response(400, err, request.state.request_id)
|
||||
assert body is not None
|
||||
if body.get("reset_sql"):
|
||||
await cache.reset_history_sql_count()
|
||||
flags = await cache.set_flags(
|
||||
singleflight=body.get("singleflight"),
|
||||
invalidate=body.get("invalidate"),
|
||||
delay_ms=body.get("delay_ms"),
|
||||
)
|
||||
return _json(flags, request.state.request_id)
|
||||
@@ -0,0 +1,56 @@
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from uuid import UUID
|
||||
|
||||
from app import config, rediscli
|
||||
from app.errors import AppError, BEARER_CHALLENGE
|
||||
|
||||
|
||||
def new_token() -> str:
|
||||
return secrets.token_urlsafe(32)
|
||||
|
||||
|
||||
def _key(token: str) -> str:
|
||||
return "sess:" + hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def _fmt(dt: datetime) -> str:
|
||||
return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
|
||||
|
||||
async def create(user_id: UUID) -> tuple[str, str]:
|
||||
token = new_token()
|
||||
expires = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
|
||||
payload = json.dumps({"user_id": str(user_id), "expires_at": _fmt(expires)})
|
||||
try:
|
||||
await rediscli.require().set(_key(token), payload, ex=config.SESSION_TTL_SECONDS)
|
||||
except AppError:
|
||||
raise
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
return token, _fmt(expires)
|
||||
|
||||
|
||||
async def resolve(token: str) -> UUID:
|
||||
try:
|
||||
raw = await rediscli.require().get(_key(token))
|
||||
except AppError:
|
||||
raise
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
if not raw:
|
||||
raise AppError(401, "authentication required", BEARER_CHALLENGE)
|
||||
return UUID(json.loads(raw)["user_id"])
|
||||
|
||||
|
||||
async def revoke(token: str) -> None:
|
||||
try:
|
||||
deleted = await rediscli.require().delete(_key(token))
|
||||
except AppError:
|
||||
raise
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
if not deleted:
|
||||
raise AppError(401, "authentication required", BEARER_CHALLENGE)
|
||||
+361
@@ -0,0 +1,361 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
from datetime import datetime, timezone
|
||||
from typing import List, Optional, Tuple
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
import asyncpg
|
||||
|
||||
from app import cache, config, db
|
||||
from app.errors import AppError
|
||||
|
||||
|
||||
def format_ts(dt: datetime) -> str:
|
||||
if dt.tzinfo is None:
|
||||
dt = dt.replace(tzinfo=timezone.utc)
|
||||
return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
|
||||
|
||||
def user_dict(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": format_ts(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def chat_dict(row, member_ids: List[str]) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"title": row["title"],
|
||||
"member_ids": member_ids,
|
||||
"created_at": format_ts(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def message_dict(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"chat_id": str(row["chat_id"]),
|
||||
"sender_id": str(row["sender_id"]),
|
||||
"text": row["text"],
|
||||
"created_at": format_ts(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
async def _run(coro):
|
||||
try:
|
||||
return await coro
|
||||
except AppError:
|
||||
raise
|
||||
except db.INTEGRITY:
|
||||
raise
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
|
||||
|
||||
async def create_user(username: str, display_name: str, password_hash: str) -> Tuple[Optional[dict], Optional[str]]:
|
||||
user_id = uuid4()
|
||||
created = datetime.now(timezone.utc)
|
||||
try:
|
||||
async with db.require().acquire() as conn:
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
""",
|
||||
user_id,
|
||||
username,
|
||||
display_name,
|
||||
password_hash,
|
||||
created,
|
||||
)
|
||||
except asyncpg.UniqueViolationError:
|
||||
return None, "conflict"
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
return user_dict({"id": user_id, "username": username, "display_name": display_name, "created_at": created}), None
|
||||
|
||||
|
||||
async def get_user(user_id: str) -> Optional[dict]:
|
||||
row = await _run(
|
||||
_fetchrow("SELECT id, username, display_name, created_at FROM users WHERE id = $1", UUID(user_id))
|
||||
)
|
||||
return user_dict(row) if row else None
|
||||
|
||||
|
||||
async def get_user_by_username(username: str):
|
||||
return await _run(
|
||||
_fetchrow(
|
||||
"SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1",
|
||||
username,
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
async def _fetchrow(sql: str, *args):
|
||||
async with db.require().acquire() as conn:
|
||||
return await conn.fetchrow(sql, *args)
|
||||
|
||||
|
||||
async def _fetch(sql: str, *args):
|
||||
async with db.require().acquire() as conn:
|
||||
return await conn.fetch(sql, *args)
|
||||
|
||||
|
||||
async def member_ids_of(chat_id: UUID) -> List[str]:
|
||||
rows = await _run(_fetch("SELECT user_id FROM chat_members WHERE chat_id = $1 ORDER BY user_id", chat_id))
|
||||
return [str(r["user_id"]) for r in rows]
|
||||
|
||||
|
||||
async def create_chat(title: str, member_ids: List[str], caller_id: str) -> Tuple[Optional[dict], Optional[str]]:
|
||||
if caller_id not in member_ids:
|
||||
return None, "caller not in members"
|
||||
if len(set(member_ids)) != len(member_ids):
|
||||
return None, "duplicate members"
|
||||
ids = [UUID(x) for x in member_ids]
|
||||
chat_id = uuid4()
|
||||
created = datetime.now(timezone.utc)
|
||||
try:
|
||||
async with db.require().acquire() as conn:
|
||||
async with conn.transaction():
|
||||
existing = await conn.fetch("SELECT id FROM users WHERE id = ANY($1::uuid[])", ids)
|
||||
if len(existing) != len(ids):
|
||||
return None, "unknown member"
|
||||
await conn.execute(
|
||||
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)",
|
||||
chat_id,
|
||||
title,
|
||||
created,
|
||||
)
|
||||
await conn.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
|
||||
[(chat_id, mid) for mid in ids],
|
||||
)
|
||||
except AppError:
|
||||
raise
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
return chat_dict({"id": chat_id, "title": title, "created_at": created}, member_ids), None
|
||||
|
||||
|
||||
async def get_chat(chat_id: str, user_id: str) -> Optional[dict]:
|
||||
row = await load_chat_for_member(chat_id, user_id)
|
||||
if row is None:
|
||||
return None
|
||||
return chat_dict(row, await member_ids_of(UUID(chat_id)))
|
||||
|
||||
|
||||
async def load_chat_for_member(chat_id: str, user_id: str):
|
||||
return await _run(
|
||||
_fetchrow(
|
||||
"""
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $2
|
||||
WHERE c.id = $1
|
||||
""",
|
||||
UUID(chat_id),
|
||||
UUID(user_id),
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
async def list_chats(user_id: str, limit: int, after: Optional[Tuple[str, str]] = None):
|
||||
args: list = [UUID(user_id)]
|
||||
clause = ""
|
||||
if after is not None:
|
||||
clause = "AND (c.created_at, c.id) > ($2, $3)"
|
||||
args.extend([datetime.fromisoformat(after[0].replace("Z", "+00:00")), UUID(after[1])])
|
||||
rows = await _run(
|
||||
_fetch(
|
||||
f"""
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $1
|
||||
WHERE 1=1 {clause}
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT {int(limit) + 1}
|
||||
""",
|
||||
*args,
|
||||
)
|
||||
)
|
||||
page = rows[:limit]
|
||||
items = [chat_dict(row, await member_ids_of(row["id"])) for row in page]
|
||||
next_key = None
|
||||
if len(rows) > limit:
|
||||
last = page[-1]
|
||||
next_key = (format_ts(last["created_at"]), str(last["id"]))
|
||||
return items, next_key
|
||||
|
||||
|
||||
def _canonical_message(text: str) -> str:
|
||||
# Missing attachment_ids and [] are the same message. Key order does not matter.
|
||||
return json.dumps(
|
||||
{"attachment_ids": [], "text": text},
|
||||
sort_keys=True,
|
||||
ensure_ascii=False,
|
||||
separators=(",", ":"),
|
||||
)
|
||||
|
||||
|
||||
async def add_message(
|
||||
chat_id: str,
|
||||
sender_id: str,
|
||||
text: str,
|
||||
idem_key: str,
|
||||
path: str,
|
||||
) -> Tuple[Optional[dict], Optional[str]]:
|
||||
"""Insert one message or replay the stored 201. The row and the result commit together.
|
||||
|
||||
Same user+method+path+key is serialized with a Postgres advisory lock so two
|
||||
replicas cannot insert two messages. A failed transaction stores nothing.
|
||||
"""
|
||||
digest = hashlib.sha256(_canonical_message(text).encode("utf-8")).hexdigest()
|
||||
lock_key = f"{sender_id}|POST|{path}|{idem_key}"
|
||||
payload: Optional[dict] = None
|
||||
created_new = False
|
||||
try:
|
||||
async with db.require().acquire() as conn:
|
||||
async with conn.transaction():
|
||||
await conn.execute("SELECT pg_advisory_xact_lock(hashtextextended($1::text, 0))", lock_key)
|
||||
member = await conn.fetchrow(
|
||||
"""
|
||||
SELECT c.id
|
||||
FROM chats c
|
||||
JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $2
|
||||
WHERE c.id = $1
|
||||
""",
|
||||
UUID(chat_id),
|
||||
UUID(sender_id),
|
||||
)
|
||||
if member is None:
|
||||
return None, "not_found"
|
||||
row = await conn.fetchrow(
|
||||
"""
|
||||
SELECT request_hash, response_json, created_at
|
||||
FROM idempotency_keys
|
||||
WHERE user_id = $1 AND http_method = 'POST' AND path = $2 AND idem_key = $3
|
||||
""",
|
||||
UUID(sender_id),
|
||||
path,
|
||||
idem_key,
|
||||
)
|
||||
if row is not None:
|
||||
created_at = row["created_at"]
|
||||
if created_at.tzinfo is None:
|
||||
created_at = created_at.replace(tzinfo=timezone.utc)
|
||||
age = (datetime.now(timezone.utc) - created_at).total_seconds()
|
||||
if age <= config.IDEMPOTENCY_TTL_SECONDS:
|
||||
if row["request_hash"] != digest:
|
||||
return None, "conflict"
|
||||
return json.loads(row["response_json"]), None
|
||||
await conn.execute(
|
||||
"""
|
||||
DELETE FROM idempotency_keys
|
||||
WHERE user_id = $1 AND http_method = 'POST' AND path = $2 AND idem_key = $3
|
||||
""",
|
||||
UUID(sender_id),
|
||||
path,
|
||||
idem_key,
|
||||
)
|
||||
message_id = uuid4()
|
||||
created = datetime.now(timezone.utc)
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
""",
|
||||
message_id,
|
||||
UUID(chat_id),
|
||||
UUID(sender_id),
|
||||
text,
|
||||
created,
|
||||
)
|
||||
payload = message_dict(
|
||||
{
|
||||
"id": message_id,
|
||||
"chat_id": UUID(chat_id),
|
||||
"sender_id": UUID(sender_id),
|
||||
"text": text,
|
||||
"created_at": created,
|
||||
}
|
||||
)
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO idempotency_keys
|
||||
(user_id, http_method, path, idem_key, request_hash, response_json, created_at)
|
||||
VALUES ($1, 'POST', $2, $3, $4, $5, $6)
|
||||
""",
|
||||
UUID(sender_id),
|
||||
path,
|
||||
idem_key,
|
||||
digest,
|
||||
json.dumps(payload, ensure_ascii=False, separators=(",", ":")),
|
||||
created,
|
||||
)
|
||||
created_new = True
|
||||
except AppError:
|
||||
raise
|
||||
except Exception:
|
||||
raise AppError(503, "service unavailable") from None
|
||||
if created_new:
|
||||
await cache.invalidate_history(chat_id)
|
||||
return payload, None
|
||||
|
||||
|
||||
async def list_messages(chat_id: str, user_id: str, limit: int, after: Optional[Tuple[str, str]] = None):
|
||||
if await load_chat_for_member(chat_id, user_id) is None:
|
||||
return None, None, "not_found"
|
||||
cursor = ""
|
||||
after_ts = after_id = None
|
||||
if after is not None:
|
||||
cursor = after[0] + ":" + after[1]
|
||||
after_ts = datetime.fromisoformat(after[0].replace("Z", "+00:00"))
|
||||
after_id = UUID(after[1])
|
||||
|
||||
async def loader() -> dict:
|
||||
await cache.incr_history_sql()
|
||||
if after_ts is None:
|
||||
rows = await _run(
|
||||
_fetch(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2
|
||||
""",
|
||||
UUID(chat_id),
|
||||
limit + 1,
|
||||
)
|
||||
)
|
||||
else:
|
||||
rows = await _run(
|
||||
_fetch(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4
|
||||
""",
|
||||
UUID(chat_id),
|
||||
after_ts,
|
||||
after_id,
|
||||
limit + 1,
|
||||
)
|
||||
)
|
||||
page = rows[:limit]
|
||||
items = [message_dict(r) for r in page]
|
||||
next_key = None
|
||||
if len(rows) > limit:
|
||||
last = page[-1]
|
||||
next_key = (format_ts(last["created_at"]), str(last["id"]))
|
||||
return {"items": items, "next_key": next_key}
|
||||
|
||||
page = await cache.get_history_page(chat_id, cursor, limit, loader)
|
||||
return page["items"], page.get("next_key"), None
|
||||
@@ -0,0 +1 @@
|
||||
|
||||
@@ -0,0 +1,73 @@
|
||||
"""Seed ≥10 000 messages and print EXPLAIN (ANALYZE, BUFFERS) for keyset pagination."""
|
||||
import asyncio
|
||||
import os
|
||||
from uuid import uuid4
|
||||
|
||||
import asyncpg
|
||||
|
||||
from app.passwords import hash_password
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
conn = await asyncpg.connect(dsn=os.environ["DATABASE_URL"], timeout=10, command_timeout=120)
|
||||
try:
|
||||
alice = uuid4()
|
||||
bob = uuid4()
|
||||
chat = uuid4()
|
||||
pwd = hash_password("Example-only-not-a-real-secret-123")
|
||||
await conn.execute(
|
||||
"INSERT INTO users (id, username, display_name, password_hash) VALUES ($1,$2,$3,$4),($5,$6,$7,$4)",
|
||||
alice,
|
||||
"explain_a_" + alice.hex[:8],
|
||||
"Alice",
|
||||
pwd,
|
||||
bob,
|
||||
"explain_b_" + bob.hex[:8],
|
||||
"Bob",
|
||||
)
|
||||
await conn.execute("INSERT INTO chats (id, title) VALUES ($1,$2)", chat, "Explain chat")
|
||||
await conn.execute(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1,$2),($1,$3)",
|
||||
chat,
|
||||
alice,
|
||||
bob,
|
||||
)
|
||||
n = int(os.environ.get("EXPLAIN_MESSAGES", "10000"))
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), $1, $2, 'seed-' || g, now() - (g || ' milliseconds')::interval
|
||||
FROM generate_series(1, $3) AS g
|
||||
""",
|
||||
chat,
|
||||
alice,
|
||||
n,
|
||||
)
|
||||
count = await conn.fetchval("SELECT count(*) FROM messages WHERE chat_id = $1", chat)
|
||||
print("seeded_messages", count, "chat_id", chat)
|
||||
first = await conn.fetchrow(
|
||||
"SELECT created_at, id FROM messages WHERE chat_id = $1 ORDER BY created_at, id LIMIT 1",
|
||||
chat,
|
||||
)
|
||||
query = """
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT 50
|
||||
"""
|
||||
print("\n=== WITH index messages_chat_created_id_idx ===")
|
||||
plan = await conn.fetch("EXPLAIN (ANALYZE, BUFFERS) " + query, chat, first["created_at"], first["id"])
|
||||
print("\n".join(row[0] for row in plan))
|
||||
await conn.execute("SET enable_indexscan = off")
|
||||
await conn.execute("SET enable_bitmapscan = off")
|
||||
await conn.execute("SET enable_indexonlyscan = off")
|
||||
print("\n=== WITHOUT index scans (seq scan baseline) ===")
|
||||
plan2 = await conn.fetch("EXPLAIN (ANALYZE, BUFFERS) " + query, chat, first["created_at"], first["id"])
|
||||
print("\n".join(row[0] for row in plan2))
|
||||
finally:
|
||||
await conn.close()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -0,0 +1,102 @@
|
||||
import json
|
||||
import re
|
||||
from typing import Any, Dict, Optional, Tuple
|
||||
from uuid import UUID
|
||||
|
||||
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
|
||||
IDEMPOTENCY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
||||
|
||||
|
||||
def parse_json_body(raw: bytes) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
|
||||
if not raw:
|
||||
return None, "empty body"
|
||||
try:
|
||||
data = json.loads(raw.decode("utf-8"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError):
|
||||
return None, "malformed JSON"
|
||||
if not isinstance(data, dict):
|
||||
return None, "JSON body must be an object"
|
||||
return data, None
|
||||
|
||||
|
||||
def require_exact_keys(data: Dict[str, Any], allowed: set, required: set) -> Optional[str]:
|
||||
keys = set(data.keys())
|
||||
if keys - allowed:
|
||||
return "unexpected fields"
|
||||
if required - keys:
|
||||
return "missing required fields"
|
||||
return None
|
||||
|
||||
|
||||
def validate_username(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str) or not USERNAME_RE.fullmatch(value):
|
||||
return "invalid username"
|
||||
return None
|
||||
|
||||
|
||||
def validate_display_name(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str):
|
||||
return "invalid display_name"
|
||||
if not value.strip():
|
||||
return "display_name must not be blank"
|
||||
if len(value) > 100:
|
||||
return "display_name too long"
|
||||
return None
|
||||
|
||||
|
||||
def validate_password(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str):
|
||||
return "invalid password"
|
||||
if not value.strip():
|
||||
return "password must not be blank"
|
||||
if len(value) < 12 or len(value) > 128:
|
||||
return "password length"
|
||||
return None
|
||||
|
||||
|
||||
def validate_title(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str):
|
||||
return "invalid title"
|
||||
if not value.strip():
|
||||
return "title must not be blank"
|
||||
if len(value) > 100:
|
||||
return "title too long"
|
||||
return None
|
||||
|
||||
|
||||
def validate_uuid(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str):
|
||||
return "invalid uuid"
|
||||
try:
|
||||
UUID(value)
|
||||
except ValueError:
|
||||
return "invalid uuid"
|
||||
return None
|
||||
|
||||
|
||||
def validate_idempotency_key(value: Optional[str]) -> Optional[str]:
|
||||
if value is None or IDEMPOTENCY_RE.fullmatch(value) is None:
|
||||
return "invalid idempotency key"
|
||||
return None
|
||||
|
||||
|
||||
def validate_message_text(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str):
|
||||
return "invalid text"
|
||||
if not value.strip():
|
||||
return "text must not be blank"
|
||||
if len(value) > 4000:
|
||||
return "text too long"
|
||||
return None
|
||||
|
||||
|
||||
def validate_limit(value: Optional[str], default: int = 50) -> Tuple[Optional[int], Optional[str]]:
|
||||
if value is None:
|
||||
return default, None
|
||||
try:
|
||||
limit = int(value)
|
||||
except ValueError:
|
||||
return None, "invalid limit"
|
||||
if limit < 1 or limit > 100:
|
||||
return None, "limit out of range"
|
||||
return limit, None
|
||||
+131
@@ -0,0 +1,131 @@
|
||||
# Port of the lab3 stand. Client -> lb:8080 -> api (scale) -> shared Postgres and Redis.
|
||||
# API replicas do not publish host ports. Migrations run once in `migrate`.
|
||||
# Check period: HAProxy inter 1s, fall 2, rise 1. Worst detection of a dead
|
||||
# or not-ready replica is about 2s, plus the 1s DNS hold. API on SIGTERM
|
||||
# fails /health/ready immediately and exits after LB_DRAIN_SECONDS (default 2).
|
||||
|
||||
services:
|
||||
migrate:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
image: mtusi-messenger:lab4
|
||||
command: ["python", "-m", "app.migrate"]
|
||||
environment:
|
||||
APP_ENV: lab
|
||||
LOG_LEVEL: info
|
||||
DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@postgres:5432/messenger
|
||||
DB_POOL_MIN: "1"
|
||||
DB_POOL_MAX: "2"
|
||||
MIGRATIONS_ON_START: "1"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
mem_limit: 256m
|
||||
cpus: "0.50"
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
image: mtusi-messenger:lab4
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: lab
|
||||
LOG_LEVEL: info
|
||||
SHUTDOWN_GRACE_SECONDS: "3"
|
||||
LB_DRAIN_SECONDS: ${LB_DRAIN_SECONDS:-2}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
CACHE_TTL_SECONDS: ${CACHE_TTL_SECONDS:-60}
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
SESSION_STORE: redis
|
||||
DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@postgres:5432/messenger
|
||||
REDIS_URL: redis://redis:6379/0
|
||||
DB_POOL_MIN: "1"
|
||||
DB_POOL_MAX: ${DB_POOL_MAX:-4}
|
||||
DB_COMMAND_TIMEOUT: "5"
|
||||
DB_CONNECT_TIMEOUT: "5"
|
||||
MIGRATIONS_ON_START: "0"
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
expose:
|
||||
- "8080"
|
||||
restart: unless-stopped
|
||||
mem_limit: ${API_MEM:-256m}
|
||||
cpus: ${API_CPUS:-0.50}
|
||||
stop_grace_period: 8s
|
||||
healthcheck:
|
||||
test:
|
||||
[
|
||||
"CMD",
|
||||
"python",
|
||||
"-c",
|
||||
"import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)",
|
||||
]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 6
|
||||
start_period: 5s
|
||||
|
||||
lb:
|
||||
image: haproxy:2.8.14-alpine
|
||||
volumes:
|
||||
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
depends_on:
|
||||
api:
|
||||
condition: service_started
|
||||
restart: unless-stopped
|
||||
mem_limit: 128m
|
||||
cpus: "0.25"
|
||||
|
||||
postgres:
|
||||
image: postgres:16.6-alpine
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
|
||||
POSTGRES_DB: messenger
|
||||
volumes:
|
||||
- pg_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
restart: unless-stopped
|
||||
mem_limit: ${POSTGRES_MEM:-512m}
|
||||
cpus: ${POSTGRES_CPUS:-1.0}
|
||||
|
||||
redis:
|
||||
image: redis:7.4.2-alpine
|
||||
command:
|
||||
- redis-server
|
||||
- --appendonly
|
||||
- "yes"
|
||||
- --appendfsync
|
||||
- everysec
|
||||
- --save
|
||||
- "60"
|
||||
- "1"
|
||||
volumes:
|
||||
- redis_data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
restart: unless-stopped
|
||||
mem_limit: 128m
|
||||
cpus: "0.50"
|
||||
|
||||
volumes:
|
||||
pg_data:
|
||||
redis_data:
|
||||
@@ -0,0 +1,35 @@
|
||||
global
|
||||
log stdout format raw local0 info
|
||||
maxconn 200
|
||||
|
||||
defaults
|
||||
log global
|
||||
mode http
|
||||
option httplog
|
||||
timeout connect 2s
|
||||
timeout client 10s
|
||||
timeout server 10s
|
||||
timeout http-request 5s
|
||||
timeout check 2s
|
||||
timeout queue 2s
|
||||
retries 1
|
||||
|
||||
resolvers docker
|
||||
nameserver dns 127.0.0.11:53
|
||||
resolve_retries 3
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
hold valid 1s
|
||||
accepted_payload_size 8192
|
||||
|
||||
frontend fe_http
|
||||
bind *:8080
|
||||
default_backend be_api
|
||||
|
||||
backend be_api
|
||||
balance roundrobin
|
||||
option httpchk
|
||||
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr host api
|
||||
http-check expect status 200
|
||||
default-server inter 1s fall 2 rise 1
|
||||
server-template srv 8 api:8080 check resolvers docker init-addr none resolve-prefer ipv4
|
||||
@@ -0,0 +1,49 @@
|
||||
-- Lab2 schema (written before application queries).
|
||||
-- Source of truth: PostgreSQL for users, chats, membership, messages.
|
||||
-- Transaction boundary: INSERT chat + INSERT members in one transaction (rollback together).
|
||||
-- Sessions are stored in Redis with AOF, not in this database.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
filename TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE users (
|
||||
id UUID PRIMARY KEY,
|
||||
username TEXT NOT NULL,
|
||||
display_name TEXT NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
CREATE UNIQUE INDEX users_username_key ON users (username);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id UUID NOT NULL REFERENCES users (id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE INDEX chat_members_user_id_idx ON chat_members (user_id);
|
||||
CREATE INDEX chats_created_at_id_idx ON chats (created_at, id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id UUID NOT NULL REFERENCES users (id),
|
||||
text TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
|
||||
);
|
||||
|
||||
-- Keyset history: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n
|
||||
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,14 @@
|
||||
-- Shared idempotency for POST /messages. Scope: user + method + path + key.
|
||||
-- The message row and this result are committed in one transaction.
|
||||
-- A rolled-back request leaves no row, so a later retry with the same key can insert.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS idempotency_keys (
|
||||
user_id UUID NOT NULL REFERENCES users (id),
|
||||
http_method TEXT NOT NULL,
|
||||
path TEXT NOT NULL,
|
||||
idem_key TEXT NOT NULL,
|
||||
request_hash TEXT NOT NULL,
|
||||
response_json TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (user_id, http_method, path, idem_key)
|
||||
);
|
||||
@@ -0,0 +1,5 @@
|
||||
starlette==0.41.3
|
||||
uvicorn[standard]==0.32.1
|
||||
asyncpg==0.30.0
|
||||
redis==5.2.1
|
||||
argon2-cffi==23.1.0
|
||||
Executable
+10
@@ -0,0 +1,10 @@
|
||||
#!/bin/sh
|
||||
# Restart API replicas and every store they use. Volumes are kept.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
if [ -f .env ]; then
|
||||
docker compose --env-file .env restart postgres redis api
|
||||
else
|
||||
docker compose restart postgres redis api
|
||||
fi
|
||||
Executable
+55
@@ -0,0 +1,55 @@
|
||||
#!/bin/sh
|
||||
# Replace API replicas one at a time. The other replica keeps serving.
|
||||
set -eu
|
||||
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
|
||||
compose() {
|
||||
if [ -f .env ]; then
|
||||
docker compose --env-file .env "$@"
|
||||
else
|
||||
docker compose "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
if command -v python3 >/dev/null 2>&1; then
|
||||
PY=python3
|
||||
else
|
||||
PY=python
|
||||
fi
|
||||
|
||||
ids=$(compose ps -q api)
|
||||
count=0
|
||||
for id in $ids; do
|
||||
count=$((count + 1))
|
||||
done
|
||||
if [ "$count" -lt 2 ]; then
|
||||
echo "rolling update needs at least 2 running API replicas" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
for id in $ids; do
|
||||
echo "replacing $(docker inspect -f '{{.Config.Hostname}}' "$id")"
|
||||
docker stop -t 8 "$id" >/dev/null
|
||||
docker rm "$id" >/dev/null
|
||||
compose up -d --scale "api=$count" --no-deps --no-recreate api >/dev/null
|
||||
ready=0
|
||||
i=0
|
||||
while [ "$i" -lt 40 ]; do
|
||||
running=0
|
||||
for cid in $(compose ps -q api); do
|
||||
running=$((running + 1))
|
||||
done
|
||||
if [ "$running" -ge "$count" ] && "$PY" -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)" >/dev/null 2>&1; then
|
||||
ready=1
|
||||
break
|
||||
fi
|
||||
i=$((i + 1))
|
||||
sleep 1
|
||||
done
|
||||
if [ "$ready" -ne 1 ]; then
|
||||
echo "replacement did not become ready" >&2
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
echo "rolling update finished; replicas=$count"
|
||||
Executable
+32
@@ -0,0 +1,32 @@
|
||||
#!/bin/sh
|
||||
# Stop the single API replica whose X-Instance-Id is TARGET_INSTANCE_ID.
|
||||
# Leaves it stopped. Does not touch the database, Redis, the load balancer, or volumes.
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
|
||||
ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
|
||||
cd "$ROOT"
|
||||
|
||||
compose() {
|
||||
if [ -f .env ]; then
|
||||
docker compose --env-file .env "$@"
|
||||
else
|
||||
docker compose "$@"
|
||||
fi
|
||||
}
|
||||
|
||||
found=0
|
||||
for id in $(compose ps -q api); do
|
||||
iid=$(docker exec "$id" cat /tmp/instance-id 2>/dev/null | tr -d '\r\n' || true)
|
||||
host=$(docker inspect -f '{{.Config.Hostname}}' "$id")
|
||||
if [ "$iid" = "$TARGET_INSTANCE_ID" ] || [ "$host" = "$TARGET_INSTANCE_ID" ]; then
|
||||
docker stop -t 5 "$id" >/dev/null
|
||||
found=1
|
||||
break
|
||||
fi
|
||||
done
|
||||
|
||||
if [ "$found" -ne 1 ]; then
|
||||
echo "no running API replica matched TARGET_INSTANCE_ID" >&2
|
||||
exit 1
|
||||
fi
|
||||
Reference in New Issue
Block a user