forked from mtusi2026/mtusi2026lab4
Carry over lab3 HA stack and add private S3 storage, Attachment API, orphan compensation/reaper, own tests, and evidence for smoke/persistence/failover.
259 lines
7.9 KiB
Python
259 lines
7.9 KiB
Python
"""HTTP-слой: тонкие обработчики (SRP: только транспорт)."""
|
|
import logging
|
|
from typing import Optional
|
|
from urllib.parse import quote
|
|
|
|
from fastapi import APIRouter, Depends, Header, Query, Request, Response
|
|
|
|
from app.auth import require_actor
|
|
from app.db import Database
|
|
from app.errors import unavailable, unsupported_media
|
|
from app.s3store import S3Store
|
|
from app.schemas import CreateChatBody, CreateMessageBody, CreateUserBody
|
|
from app.services import (
|
|
AttachmentService,
|
|
AuthService,
|
|
ChatService,
|
|
MessageService,
|
|
UserService,
|
|
)
|
|
from app.sessions import SessionStore
|
|
from app.upload import read_body_limited
|
|
|
|
logger = logging.getLogger("messenger")
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
def _state(request: Request):
|
|
db: Database = request.app.state.db
|
|
sessions: SessionStore = request.app.state.sessions
|
|
s3: S3Store = request.app.state.s3
|
|
return db, sessions, s3
|
|
|
|
|
|
def require_json_content_type(request: Request) -> None:
|
|
content_type = request.headers.get("content-type", "")
|
|
media = content_type.split(";")[0].strip().lower()
|
|
if media != "application/json":
|
|
raise unsupported_media()
|
|
|
|
|
|
def _require_accepting(db: Database) -> None:
|
|
if not db.accepting:
|
|
raise unavailable("Сервер завершает работу")
|
|
|
|
|
|
@router.get("/health/live")
|
|
def live():
|
|
return {"status": "ok"}
|
|
|
|
|
|
@router.get("/health/ready")
|
|
def ready(request: Request):
|
|
db, sessions, s3 = _state(request)
|
|
if not db.ready or not db.accepting:
|
|
raise unavailable("Не готов принимать трафик")
|
|
if not db.ping() or not sessions.ping() or not s3.ping():
|
|
raise unavailable("Зависимость недоступна")
|
|
return {"status": "ok"}
|
|
|
|
|
|
@router.post("/api/v1/users", status_code=201)
|
|
def create_user(
|
|
request: Request,
|
|
body: CreateUserBody,
|
|
_: None = Depends(require_json_content_type),
|
|
):
|
|
db, _sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
return UserService(db).create(body.model_dump())
|
|
|
|
|
|
@router.post("/api/v1/auth/sessions", status_code=201)
|
|
def create_session(
|
|
request: Request,
|
|
authorization: Optional[str] = Header(default=None),
|
|
):
|
|
db, sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
return AuthService(db, sessions).create_session(authorization)
|
|
|
|
|
|
@router.delete("/api/v1/auth/sessions/current", status_code=204)
|
|
def revoke_session(
|
|
request: Request,
|
|
authorization: Optional[str] = Header(default=None),
|
|
):
|
|
db, sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
_actor, token = require_actor(db, sessions, authorization)
|
|
AuthService(db, sessions).logout(token)
|
|
return Response(status_code=204)
|
|
|
|
|
|
@router.get("/api/v1/users/me")
|
|
def current_user(
|
|
request: Request,
|
|
authorization: Optional[str] = Header(default=None),
|
|
):
|
|
db, sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
return actor.to_dict()
|
|
|
|
|
|
@router.post("/api/v1/chats", status_code=201)
|
|
def create_chat(
|
|
request: Request,
|
|
body: CreateChatBody,
|
|
authorization: Optional[str] = Header(default=None),
|
|
_: None = Depends(require_json_content_type),
|
|
):
|
|
db, sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
return ChatService(db).create(actor, body.model_dump())
|
|
|
|
|
|
@router.get("/api/v1/chats")
|
|
def list_chats(
|
|
request: Request,
|
|
authorization: Optional[str] = Header(default=None),
|
|
limit: Optional[str] = Query(default=None),
|
|
cursor: Optional[str] = Query(default=None),
|
|
):
|
|
db, sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
return ChatService(db).list_for_user(actor, limit, cursor)
|
|
|
|
|
|
@router.get("/api/v1/chats/{chat_id}")
|
|
def get_chat(
|
|
chat_id: str,
|
|
request: Request,
|
|
authorization: Optional[str] = Header(default=None),
|
|
):
|
|
db, sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
return ChatService(db).get_for_member(actor, chat_id).to_dict()
|
|
|
|
|
|
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
|
def create_message(
|
|
chat_id: str,
|
|
request: Request,
|
|
body: CreateMessageBody,
|
|
authorization: Optional[str] = Header(default=None),
|
|
idempotency_key: Optional[str] = Header(default=None, alias="Idempotency-Key"),
|
|
_: None = Depends(require_json_content_type),
|
|
):
|
|
db, sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
chats = ChatService(db)
|
|
chat = chats.get_for_member(actor, chat_id)
|
|
path = f"/api/v1/chats/{chat.id}/messages"
|
|
result = MessageService(db).create(
|
|
actor,
|
|
chat,
|
|
body.model_dump(),
|
|
idempotency_key=idempotency_key,
|
|
method="POST",
|
|
path=path,
|
|
)
|
|
logger.info(
|
|
"message created chat_id=%s sender_id=%s message_id=%s",
|
|
chat.id,
|
|
actor.id,
|
|
result["id"],
|
|
)
|
|
return result
|
|
|
|
|
|
@router.get("/api/v1/chats/{chat_id}/messages")
|
|
def list_messages(
|
|
chat_id: str,
|
|
request: Request,
|
|
authorization: Optional[str] = Header(default=None),
|
|
limit: Optional[str] = Query(default=None),
|
|
cursor: Optional[str] = Query(default=None),
|
|
):
|
|
db, sessions, _s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
chat = ChatService(db).get_for_member(actor, chat_id)
|
|
return MessageService(db).list_for_chat(chat, limit, cursor)
|
|
|
|
|
|
@router.post("/api/v1/chats/{chat_id}/attachments", status_code=201)
|
|
async def upload_attachment(
|
|
chat_id: str,
|
|
request: Request,
|
|
filename: Optional[str] = Query(default=None),
|
|
authorization: Optional[str] = Header(default=None),
|
|
):
|
|
db, sessions, s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
chat = ChatService(db).get_for_member(actor, chat_id)
|
|
content_type = request.headers.get("content-type", "")
|
|
media = content_type.split(";")[0].strip().lower()
|
|
if media not in ("image/png", "image/jpeg"):
|
|
raise unsupported_media("Content-Type должен быть image/png или image/jpeg")
|
|
data = await read_body_limited(request)
|
|
result = AttachmentService(db, s3).upload(
|
|
actor,
|
|
chat,
|
|
filename_raw=filename,
|
|
content_type=media,
|
|
data=data,
|
|
)
|
|
logger.info(
|
|
"attachment uploaded chat_id=%s attachment_id=%s size=%s",
|
|
chat.id,
|
|
result["id"],
|
|
result["size_bytes"],
|
|
)
|
|
return result
|
|
|
|
|
|
@router.get("/api/v1/attachments/{attachment_id}")
|
|
def get_attachment(
|
|
attachment_id: str,
|
|
request: Request,
|
|
authorization: Optional[str] = Header(default=None),
|
|
):
|
|
db, sessions, s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
return AttachmentService(db, s3).get_for_member(actor, attachment_id).to_dict()
|
|
|
|
|
|
@router.get("/api/v1/attachments/{attachment_id}/content")
|
|
def download_attachment(
|
|
attachment_id: str,
|
|
request: Request,
|
|
authorization: Optional[str] = Header(default=None),
|
|
variant: Optional[str] = Query(default=None),
|
|
):
|
|
db, sessions, s3 = _state(request)
|
|
_require_accepting(db)
|
|
actor, _token = require_actor(db, sessions, authorization)
|
|
if variant is not None and variant != "" and variant != "original":
|
|
from app.errors import not_found
|
|
|
|
raise not_found("Вариант не найден")
|
|
att, data = AttachmentService(db, s3).download_for_member(actor, attachment_id)
|
|
filename = quote(att.filename)
|
|
return Response(
|
|
content=data,
|
|
media_type=att.content_type,
|
|
headers={
|
|
"Content-Length": str(len(data)),
|
|
"Content-Disposition": f"inline; filename*=UTF-8''{filename}",
|
|
},
|
|
)
|