428 lines
12 KiB
Python
428 lines
12 KiB
Python
import base64
|
|
import binascii
|
|
import json
|
|
import logging
|
|
import re
|
|
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)
|
|
|
|
|
|
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
|
|
|
|
|
|
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 USERNAME_RE.fullmatch(username) and 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,
|
|
)
|