212 lines
6.9 KiB
Python
212 lines
6.9 KiB
Python
import base64
|
|
import binascii
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
import time
|
|
from contextlib import asynccontextmanager
|
|
from uuid import uuid4
|
|
|
|
from fastapi import Depends, FastAPI, Request, Response
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from starlette.exceptions import HTTPException
|
|
|
|
from .domain import Failure, boundary, identifier, page
|
|
from .models import CreateChat, CreateMessage, CreateUser
|
|
from .postgres import PostgresStore
|
|
|
|
logger = logging.getLogger("messenger")
|
|
logging.basicConfig(level=os.getenv("LOG_LEVEL", "INFO"), format="%(message)s")
|
|
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",
|
|
}
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app):
|
|
app.state.store = PostgresStore()
|
|
logger.info(json.dumps({"event": "started", "storage": "postgres"}))
|
|
yield
|
|
app.state.store.close()
|
|
logger.info(json.dumps({"event": "stopped"}))
|
|
|
|
|
|
app = FastAPI(lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
|
|
|
|
|
|
def error(request, status, message, headers=None):
|
|
return JSONResponse(
|
|
{
|
|
"error": {
|
|
"code": CODES.get(status, "invalid_request"),
|
|
"message": message,
|
|
"request_id": request.state.request_id,
|
|
}
|
|
},
|
|
status_code=status,
|
|
headers=headers,
|
|
)
|
|
|
|
|
|
@app.middleware("http")
|
|
async def request_log(request: Request, call_next):
|
|
request.state.request_id = str(uuid4())
|
|
start = time.perf_counter()
|
|
try:
|
|
response = await call_next(request)
|
|
except Exception:
|
|
logger.error(
|
|
json.dumps({"event": "unexpected_error", "request_id": request.state.request_id})
|
|
)
|
|
response = error(request, 500, "Внутренняя ошибка")
|
|
response.headers["X-Request-Id"] = request.state.request_id
|
|
route = request.scope.get("route")
|
|
logger.info(
|
|
json.dumps(
|
|
{
|
|
"event": "request",
|
|
"request_id": request.state.request_id,
|
|
"method": request.method,
|
|
"route": getattr(route, "path", "unknown"),
|
|
"status": response.status_code,
|
|
"duration_ms": round((time.perf_counter() - start) * 1000, 3),
|
|
}
|
|
)
|
|
)
|
|
return response
|
|
|
|
|
|
@app.exception_handler(Failure)
|
|
async def domain_error(request, exc):
|
|
return error(request, exc.status, exc.message, exc.headers)
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_error(request, exc):
|
|
return error(request, 400, "Неверный JSON или поля запроса")
|
|
|
|
|
|
@app.exception_handler(HTTPException)
|
|
async def http_error(request, exc):
|
|
return error(request, exc.status_code, "Неверный запрос", exc.headers)
|
|
|
|
|
|
def bearer_failure():
|
|
return Failure(
|
|
401, "Требуется действующая сессия", {"WWW-Authenticate": 'Bearer realm="messenger"'}
|
|
)
|
|
|
|
|
|
def bearer(request):
|
|
parts = request.headers.get("Authorization", "").split()
|
|
if len(parts) != 2 or parts[0].lower() != "bearer":
|
|
raise bearer_failure()
|
|
return parts[1]
|
|
|
|
|
|
def actor(request: Request):
|
|
user = request.app.state.store.authenticate(bearer(request))
|
|
if user is None:
|
|
raise bearer_failure()
|
|
return user
|
|
|
|
|
|
@app.post("/api/v1/auth/sessions", status_code=201)
|
|
def login(request: Request):
|
|
headers = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
|
parts = request.headers.get("Authorization", "").split()
|
|
try:
|
|
if len(parts) != 2 or parts[0].lower() != "basic" or len(parts[1]) > 2048:
|
|
raise ValueError
|
|
decoded = base64.b64decode(parts[1], validate=True).decode("utf-8")
|
|
username, password = decoded.split(":", 1)
|
|
if not re.fullmatch(r"[a-z0-9_]{3,32}", username) or not 12 <= len(password) <= 128:
|
|
raise ValueError
|
|
except (ValueError, UnicodeError, binascii.Error):
|
|
raise Failure(401, "Неверные учётные данные", headers) from None
|
|
session = request.app.state.store.login(username, password)
|
|
if session is None:
|
|
raise Failure(401, "Неверные учётные данные", headers)
|
|
return session
|
|
|
|
|
|
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
|
def logout(request: Request, user=Depends(actor)):
|
|
if not request.app.state.store.logout(bearer(request)):
|
|
raise bearer_failure()
|
|
return Response(status_code=204)
|
|
|
|
|
|
def pagination(request, scope):
|
|
allowed = {"limit", "cursor"}
|
|
if any(k not in allowed for k in request.query_params):
|
|
raise Failure(400, "Неизвестный параметр запроса")
|
|
if any(len(request.query_params.getlist(k)) > 1 for k in allowed):
|
|
raise Failure(400, "Повторный параметр запроса")
|
|
value = request.query_params.get("limit", "50")
|
|
if len(value) > 3 or not re.fullmatch(r"[0-9]+", value) or not 1 <= int(value) <= 100:
|
|
raise Failure(400, "limit должен быть целым от 1 до 100")
|
|
return int(value), boundary(scope, request.query_params.get("cursor"))
|
|
|
|
|
|
@app.get("/health/live")
|
|
def live():
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get("/health/ready")
|
|
def ready(request: Request):
|
|
if not request.app.state.store.ready():
|
|
raise Failure(503, "Хранилище недоступно")
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.post("/api/v1/users", status_code=201)
|
|
def register(data: CreateUser, request: Request):
|
|
return request.app.state.store.register(data.model_dump(mode="json"))
|
|
|
|
|
|
@app.get("/api/v1/users/me")
|
|
def me(user=Depends(actor)):
|
|
return user
|
|
|
|
|
|
@app.post("/api/v1/chats", status_code=201)
|
|
def create_chat(data: CreateChat, request: Request, user=Depends(actor)):
|
|
return request.app.state.store.create_chat(user["id"], data.model_dump(mode="json"))
|
|
|
|
|
|
@app.get("/api/v1/chats")
|
|
def chats(request: Request, user=Depends(actor)):
|
|
scope = "chats:" + user["id"]
|
|
limit, after = pagination(request, scope)
|
|
return page(request.app.state.store.list_chats(user["id"], after, limit), limit, scope)
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}")
|
|
def chat(chat_id: str, request: Request, user=Depends(actor)):
|
|
return request.app.state.store.chat(user["id"], identifier(chat_id))
|
|
|
|
|
|
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
|
def send(chat_id: str, data: CreateMessage, request: Request, user=Depends(actor)):
|
|
return request.app.state.store.send(user["id"], identifier(chat_id), data.text)
|
|
|
|
|
|
@app.get("/api/v1/chats/{chat_id}/messages")
|
|
def history(chat_id: str, request: Request, user=Depends(actor)):
|
|
cid = identifier(chat_id)
|
|
scope = "messages:" + cid
|
|
limit, after = pagination(request, scope)
|
|
return page(request.app.state.store.history(user["id"], cid, after, limit), limit, scope)
|