forked from mtusi2026/mtusi2026lab2
436 lines
12 KiB
Python
436 lines
12 KiB
Python
"""Мессенджер, lab2: HTTP API по contracts/openapi.json.
|
||
|
||
Что изменилось с lab1:
|
||
- данные (users, chats, messages) теперь в PostgreSQL, а не в словарях: см. db.py;
|
||
- регистрация принимает password, вход — POST /auth/sessions с Basic, выход — DELETE;
|
||
- текущий пользователь определяется только по Bearer-токену (сессии в Redis, см. auth.py),
|
||
заголовок X-User-Id больше ничего не значит.
|
||
Модели, формат ошибок, X-Request-Id и курсоры остались из lab1.
|
||
"""
|
||
import base64
|
||
import binascii
|
||
import json
|
||
import logging
|
||
import time
|
||
import uuid
|
||
from contextlib import asynccontextmanager
|
||
from datetime import datetime
|
||
from uuid import UUID
|
||
|
||
import uvicorn
|
||
from fastapi import FastAPI, Header, Query, Request, Response
|
||
from fastapi.exceptions import RequestValidationError
|
||
from fastapi.responses import JSONResponse
|
||
from pydantic import BaseModel, ConfigDict, Field, field_validator
|
||
from starlette.concurrency import run_in_threadpool
|
||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||
|
||
import auth
|
||
import db
|
||
import settings
|
||
from errors import ApiError, bad_request, unauthorized
|
||
|
||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
|
||
log = logging.getLogger("messenger")
|
||
|
||
|
||
@asynccontextmanager
|
||
async def lifespan(app: FastAPI):
|
||
settings.check()
|
||
await run_in_threadpool(db.wait_and_migrate)
|
||
db.pool.open()
|
||
log.info("Started: env=%s, session TTL=%s s, sessions in Redis", settings.APP_ENV, settings.SESSION_TTL_SECONDS)
|
||
yield
|
||
db.pool.close()
|
||
auth.close()
|
||
log.info("Stopped: connections closed, data stays in PostgreSQL and Redis")
|
||
|
||
|
||
app = FastAPI(lifespan=lifespan)
|
||
|
||
|
||
|
||
class CreateUser(BaseModel):
|
||
model_config = ConfigDict(extra="forbid")
|
||
|
||
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
|
||
display_name: str = Field(min_length=1, max_length=100)
|
||
password: str = Field(min_length=auth.PASSWORD_MIN_LENGTH, max_length=auth.PASSWORD_MAX_LENGTH)
|
||
|
||
@field_validator("display_name", "password")
|
||
@classmethod
|
||
def validate_not_blank(cls, value: str) -> str:
|
||
if not value.strip():
|
||
raise ValueError("value cannot be blank")
|
||
return value
|
||
|
||
|
||
class User(BaseModel):
|
||
id: UUID
|
||
username: str
|
||
display_name: str
|
||
created_at: datetime
|
||
|
||
|
||
class Session(BaseModel):
|
||
token: str
|
||
token_type: str
|
||
expires_at: datetime
|
||
user: User
|
||
|
||
|
||
class CreateChat(BaseModel):
|
||
model_config = ConfigDict(extra="forbid")
|
||
|
||
title: str = Field(min_length=1, max_length=100)
|
||
member_ids: list[UUID] = Field(min_length=1, max_length=100)
|
||
|
||
@field_validator("title")
|
||
@classmethod
|
||
def validate_title(cls, value: str) -> str:
|
||
if not value.strip():
|
||
raise ValueError("title cannot be empty")
|
||
return value
|
||
|
||
|
||
class Chat(BaseModel):
|
||
id: UUID
|
||
title: str
|
||
member_ids: list[UUID]
|
||
created_at: datetime
|
||
|
||
|
||
class ChatPage(BaseModel):
|
||
items: list[Chat]
|
||
next_cursor: str | None
|
||
|
||
|
||
class CreateMessage(BaseModel):
|
||
model_config = ConfigDict(extra="forbid")
|
||
|
||
text: str = Field(max_length=4000)
|
||
|
||
@field_validator("text")
|
||
@classmethod
|
||
def validate_text(cls, value: str) -> str:
|
||
if not value.strip():
|
||
raise ValueError("text cannot be empty")
|
||
return value
|
||
|
||
|
||
class Message(BaseModel):
|
||
id: UUID
|
||
chat_id: UUID
|
||
sender_id: UUID
|
||
text: str
|
||
created_at: datetime
|
||
|
||
|
||
class MessagePage(BaseModel):
|
||
items: list[Message]
|
||
next_cursor: str | None
|
||
|
||
|
||
def error_response(
|
||
request: Request,
|
||
code: str,
|
||
message: str,
|
||
status_code: int,
|
||
headers: dict | None = None,
|
||
):
|
||
request_id = request.state.request_id
|
||
|
||
return JSONResponse(
|
||
status_code=status_code,
|
||
content={
|
||
"error": {
|
||
"code": code,
|
||
"message": message,
|
||
"request_id": request_id,
|
||
}
|
||
},
|
||
headers={"X-Request-Id": request_id, **(headers or {})},
|
||
)
|
||
|
||
|
||
@app.exception_handler(ApiError)
|
||
async def api_error_handler(request: Request, exc: ApiError):
|
||
return error_response(request, exc.code, exc.message, exc.status_code, exc.headers)
|
||
|
||
|
||
@app.exception_handler(RequestValidationError)
|
||
async def validation_exception_handler(
|
||
request: Request,
|
||
exc: RequestValidationError,
|
||
):
|
||
return error_response(
|
||
request,
|
||
"invalid_request",
|
||
"Invalid request data",
|
||
400,
|
||
)
|
||
|
||
|
||
@app.exception_handler(StarletteHTTPException)
|
||
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
||
if exc.status_code == 404:
|
||
return error_response(request, "not_found", "Not found", 404)
|
||
return error_response(request, "invalid_request", "Request cannot be processed", exc.status_code, exc.headers)
|
||
|
||
|
||
@app.exception_handler(Exception)
|
||
async def general_exception_handler(
|
||
request: Request,
|
||
exc: Exception,
|
||
):
|
||
return error_response(
|
||
request,
|
||
"internal_error",
|
||
"Internal server error",
|
||
500,
|
||
)
|
||
|
||
PUBLIC_ENDPOINTS = {
|
||
("POST", "/api/v1/users"),
|
||
("POST", "/api/v1/auth/sessions"),
|
||
}
|
||
|
||
|
||
@app.middleware("http")
|
||
async def request_context(request: Request, call_next):
|
||
request_id = str(uuid.uuid4())
|
||
request.state.request_id = request_id
|
||
started = time.perf_counter()
|
||
|
||
try:
|
||
path = request.url.path
|
||
if path.startswith("/api/") and (request.method, path) not in PUBLIC_ENDPOINTS:
|
||
request.state.session = await run_in_threadpool(
|
||
auth.check_bearer, request.headers.get("Authorization")
|
||
)
|
||
response = await call_next(request)
|
||
except ApiError as exc:
|
||
response = error_response(request, exc.code, exc.message, exc.status_code, exc.headers)
|
||
except Exception:
|
||
log.exception("Unhandled error, request_id=%s", request_id)
|
||
response = error_response(request, "internal_error", "Internal server error", 500)
|
||
|
||
response.headers["X-Request-Id"] = request_id
|
||
log.info(
|
||
"%s %s -> %s (%.1f ms) request_id=%s",
|
||
request.method, request.url.path, response.status_code,
|
||
(time.perf_counter() - started) * 1000, request_id,
|
||
)
|
||
return response
|
||
|
||
|
||
def current_user_id(request: Request) -> UUID:
|
||
session = getattr(request.state, "session", None)
|
||
if session is None:
|
||
raise unauthorized("Bearer token is required")
|
||
return session.user_id
|
||
|
||
|
||
def encode_cursor(
|
||
created_at: datetime,
|
||
object_id: UUID,
|
||
*,
|
||
chat_id: UUID | None = None,
|
||
user_id: UUID | None = None,
|
||
) -> str:
|
||
data = {
|
||
"created_at": created_at.isoformat(),
|
||
"id": str(object_id),
|
||
}
|
||
|
||
if chat_id is not None:
|
||
data["chat_id"] = str(chat_id)
|
||
|
||
if user_id is not None:
|
||
data["user_id"] = str(user_id)
|
||
|
||
raw = json.dumps(data).encode("utf-8")
|
||
return base64.urlsafe_b64encode(raw).decode("ascii")
|
||
|
||
|
||
def decode_cursor(cursor: str):
|
||
try:
|
||
raw = base64.urlsafe_b64decode(cursor.encode("ascii"))
|
||
data = json.loads(raw.decode("utf-8"))
|
||
|
||
created_at = datetime.fromisoformat(data["created_at"])
|
||
|
||
if created_at.tzinfo is None:
|
||
raise ValueError("Invalid cursor")
|
||
|
||
if not isinstance(data["id"], str):
|
||
raise ValueError("Invalid cursor")
|
||
|
||
object_id = UUID(data["id"])
|
||
|
||
chat_id = UUID(data["chat_id"]) if "chat_id" in data else None
|
||
user_id = UUID(data["user_id"]) if "user_id" in data else None
|
||
|
||
return created_at, object_id, chat_id, user_id
|
||
|
||
except (
|
||
ValueError,
|
||
KeyError,
|
||
TypeError,
|
||
AttributeError,
|
||
json.JSONDecodeError,
|
||
binascii.Error,
|
||
):
|
||
raise ValueError("Invalid cursor")
|
||
|
||
|
||
def page_after(cursor: str | None, *, chat_id: UUID | None = None, user_id: UUID | None = None):
|
||
"""Курсор -> ключ (created_at, id), с которого продолжать. Чужой или битый курсор — 400."""
|
||
if not cursor:
|
||
return None
|
||
try:
|
||
created_at, object_id, cursor_chat_id, cursor_user_id = decode_cursor(cursor)
|
||
except ValueError:
|
||
raise bad_request("Invalid cursor") from None
|
||
if cursor_chat_id != chat_id or cursor_user_id != user_id:
|
||
raise bad_request("Invalid cursor")
|
||
return created_at, object_id
|
||
|
||
|
||
|
||
@app.get("/health/live")
|
||
def health_live():
|
||
return {"status": "ok"}
|
||
|
||
|
||
@app.get("/health/ready")
|
||
def health_ready():
|
||
db.ping()
|
||
auth.ping_redis()
|
||
return {"status": "ok"}
|
||
|
||
|
||
|
||
@app.post("/api/v1/users", response_model=User, status_code=201)
|
||
def create_user(user_data: CreateUser):
|
||
password_hash = auth.hash_password(user_data.password) # сам пароль нигде не сохраняется
|
||
return db.create_user(user_data.username, user_data.display_name, password_hash)
|
||
|
||
|
||
@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201)
|
||
def create_session(
|
||
response: Response,
|
||
authorization: str | None = Header(default=None),
|
||
):
|
||
credentials = auth.parse_basic(authorization)
|
||
if credentials is None:
|
||
raise auth.login_failed()
|
||
username, password = credentials
|
||
|
||
found = None
|
||
if len(password) <= auth.PASSWORD_MAX_LENGTH:
|
||
found = db.get_user_with_password(username)
|
||
if not auth.password_matches(found["password_hash"] if found else None, password):
|
||
raise auth.login_failed()
|
||
|
||
token, expires_at = auth.create_session(found["id"])
|
||
response.headers["Cache-Control"] = "no-store"
|
||
user = {key: found[key] for key in ("id", "username", "display_name", "created_at")}
|
||
return {"token": token, "token_type": "Bearer", "expires_at": expires_at, "user": user}
|
||
|
||
|
||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||
def delete_session(request: Request):
|
||
current_user_id(request)
|
||
auth.delete_session(request.state.session)
|
||
return Response(status_code=204)
|
||
|
||
|
||
@app.get("/api/v1/users/me", response_model=User)
|
||
def get_current_user(request: Request):
|
||
user = db.get_user(current_user_id(request))
|
||
if user is None:
|
||
raise unauthorized("Session is invalid or expired")
|
||
return user
|
||
|
||
|
||
|
||
@app.post("/api/v1/chats", response_model=Chat, status_code=201)
|
||
def create_chat(request: Request, chat_data: CreateChat):
|
||
user_id = current_user_id(request)
|
||
|
||
if user_id not in chat_data.member_ids:
|
||
raise bad_request("Creator must be a chat member")
|
||
|
||
if len(chat_data.member_ids) != len(set(chat_data.member_ids)):
|
||
raise bad_request("Duplicate member IDs")
|
||
return db.create_chat(chat_data.title, chat_data.member_ids)
|
||
|
||
|
||
@app.get("/api/v1/chats", response_model=ChatPage)
|
||
def list_chats(
|
||
request: Request,
|
||
limit: int = Query(default=50, ge=1, le=100),
|
||
cursor: str | None = Query(default=None),
|
||
):
|
||
user_id = current_user_id(request)
|
||
after = page_after(cursor, user_id=user_id)
|
||
|
||
rows = db.list_chats(user_id, after, limit)
|
||
items = rows[:limit]
|
||
|
||
next_cursor = None
|
||
if len(rows) > limit:
|
||
last = items[-1]
|
||
next_cursor = encode_cursor(last["created_at"], last["id"], user_id=user_id)
|
||
|
||
return ChatPage(items=items, next_cursor=next_cursor)
|
||
|
||
|
||
@app.get("/api/v1/chats/{chat_id}", response_model=Chat)
|
||
def get_chat(request: Request, chat_id: UUID):
|
||
return db.get_chat(chat_id, current_user_id(request))
|
||
|
||
|
||
@app.post(
|
||
"/api/v1/chats/{chat_id}/messages",
|
||
response_model=Message,
|
||
status_code=201,
|
||
)
|
||
def create_message(request: Request, message_data: CreateMessage, chat_id: UUID):
|
||
return db.add_message(chat_id, current_user_id(request), message_data.text)
|
||
|
||
|
||
@app.get(
|
||
"/api/v1/chats/{chat_id}/messages",
|
||
response_model=MessagePage,
|
||
)
|
||
def list_messages(
|
||
request: Request,
|
||
chat_id: UUID,
|
||
limit: int = Query(default=50, ge=1, le=100),
|
||
cursor: str | None = Query(default=None),
|
||
):
|
||
user_id = current_user_id(request)
|
||
after = page_after(cursor, chat_id=chat_id)
|
||
|
||
rows = db.list_messages(chat_id, user_id, after, limit)
|
||
items = rows[:limit]
|
||
|
||
next_cursor = None
|
||
if len(rows) > limit:
|
||
last = items[-1]
|
||
next_cursor = encode_cursor(last["created_at"], last["id"], chat_id=chat_id)
|
||
|
||
return MessagePage(items=items, next_cursor=next_cursor)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
uvicorn.run(
|
||
app,
|
||
host=settings.APP_HOST,
|
||
port=settings.APP_PORT,
|
||
timeout_graceful_shutdown=settings.SHUTDOWN_TIMEOUT_SECONDS,
|
||
access_log=False,
|
||
)
|