171 lines
6.6 KiB
Python
171 lines
6.6 KiB
Python
import hashlib
|
|
import logging
|
|
import os
|
|
import re
|
|
import secrets
|
|
from contextlib import asynccontextmanager
|
|
from uuid import UUID, uuid4
|
|
|
|
import anyio
|
|
import psycopg
|
|
from fastapi import Depends, FastAPI, Query, Request, Response
|
|
from fastapi.exceptions import RequestValidationError
|
|
from psycopg_pool import PoolTimeout, TooManyRequests
|
|
from starlette.exceptions import HTTPException
|
|
|
|
from src import store
|
|
from src.config import SESSION_TTL
|
|
from src.db import connection, pool
|
|
from src.errors import ApiError, error_response
|
|
from src.models import Chat, ChatPage, CreateChat, CreateMessage, CreateUser, Message, MessagePage, User
|
|
from src.security import basic_credentials, hasher, token_hash, unauthorized, verify
|
|
|
|
|
|
INSTANCE_ID = os.getenv("INSTANCE_ID") or uuid4().hex
|
|
IDEMPOTENCY_KEY = re.compile(r"[A-Za-z0-9._:-]{1,128}")
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app):
|
|
anyio.to_thread.current_default_thread_limiter().total_tokens = 16
|
|
pool.open()
|
|
try:
|
|
pool.wait(timeout=10)
|
|
yield
|
|
finally:
|
|
pool.close()
|
|
|
|
|
|
app = FastAPI(title="MTUSI Messenger", version="1.3.0", lifespan=lifespan,
|
|
docs_url=None, redoc_url=None, openapi_url=None)
|
|
|
|
|
|
def failure(request, status, code, message):
|
|
response = error_response(request, status, code, message)
|
|
if status == 401:
|
|
basic = request.url.path == "/api/v1/auth/sessions"
|
|
response.headers['WWW-Authenticate'] = ('Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"')
|
|
return response
|
|
|
|
|
|
@app.middleware("http")
|
|
async def request_context(request, call_next):
|
|
request.state.request_id = str(uuid4())
|
|
try:
|
|
if request.method == "POST" and request.url.path == "/api/v1/auth/sessions" and await request.body():
|
|
raise ApiError(400, "invalid_request", "Вход не принимает тело запроса")
|
|
response = await call_next(request)
|
|
except ApiError as exc:
|
|
response = failure(request, exc.status_code, exc.code, exc.message)
|
|
except (psycopg.Error, PoolTimeout, TooManyRequests):
|
|
response = failure(request, 503, "unavailable", "Хранилище временно недоступно")
|
|
except Exception as exc:
|
|
logging.error("Unhandled request error: %s", type(exc).__name__)
|
|
response = failure(request, 500, "internal_error", "Внутренняя ошибка сервера")
|
|
response.headers['X-Request-Id'] = request.state.request_id
|
|
response.headers['X-Instance-Id'] = INSTANCE_ID
|
|
return response
|
|
|
|
|
|
@app.exception_handler(ApiError)
|
|
async def api_error(request, exc):
|
|
return failure(request, exc.status_code, exc.code, exc.message)
|
|
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_error(request, exc):
|
|
return failure(request, 400, "invalid_request", "Некорректный запрос")
|
|
|
|
|
|
@app.exception_handler(HTTPException)
|
|
async def http_error(request, exc):
|
|
return failure(request, exc.status_code, "not_found" if exc.status_code == 404 else "invalid_request", "Недопустимый HTTP-запрос")
|
|
|
|
|
|
def require_user(request: Request):
|
|
digest = token_hash(request.headers.get('Authorization'))
|
|
with connection() as conn:
|
|
user = conn.execute(
|
|
"""SELECT u.id,u.username,u.display_name,u.created_at
|
|
FROM sessions s JOIN users u ON u.id=s.user_id
|
|
WHERE s.token_hash=%s AND s.expires_at > clock_timestamp()""",
|
|
(digest,),
|
|
).fetchone()
|
|
if user is None:
|
|
unauthorized()
|
|
request.state.token_hash = digest
|
|
return User(**store.public(user))
|
|
|
|
|
|
@app.get('/health/live')
|
|
def live():
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.get('/health/ready')
|
|
def ready():
|
|
with connection() as conn:
|
|
conn.execute("SELECT 1").fetchone()
|
|
return {"status": "ok"}
|
|
|
|
|
|
@app.post('/api/v1/users', status_code=201, response_model=User)
|
|
def register(data: CreateUser):
|
|
return store.create_user(data, hasher.hash(data.password))
|
|
|
|
|
|
@app.post('/api/v1/auth/sessions', status_code=201)
|
|
def login(request: Request):
|
|
username, password = basic_credentials(request.headers.get('Authorization'))
|
|
with connection() as conn:
|
|
row = conn.execute("SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=%s", (username,)).fetchone()
|
|
valid = verify(row['password_hash'] if row else None, password)
|
|
if not row or not valid:
|
|
unauthorized()
|
|
token = secrets.token_urlsafe(32)
|
|
digest = hashlib.sha256(token.encode('ascii')).digest()
|
|
with connection() as conn:
|
|
result = conn.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at", (digest, row['id'], SESSION_TTL)).fetchone()
|
|
del row['password_hash']
|
|
return {"token": token, "token_type": "Bearer", "expires_at": store.public(result['expires_at']), "user": store.public(row)}
|
|
|
|
|
|
@app.delete('/api/v1/auth/sessions/current', status_code=204)
|
|
def logout(request: Request, user: User = Depends(require_user)):
|
|
with connection() as conn:
|
|
conn.execute("DELETE FROM sessions WHERE token_hash=%s", (request.state.token_hash,))
|
|
return Response(status_code=204)
|
|
|
|
|
|
@app.get('/api/v1/users/me', response_model=User)
|
|
def me(user: User = Depends(require_user)):
|
|
return user
|
|
|
|
|
|
@app.post('/api/v1/chats', status_code=201, response_model=Chat)
|
|
def create_chat(data: CreateChat, user: User = Depends(require_user)):
|
|
return store.create_chat(data, user.id)
|
|
|
|
|
|
@app.get('/api/v1/chats', response_model=ChatPage)
|
|
def chats(user: User = Depends(require_user), limit: int = Query(50, ge=1, le=100), cursor: str | None = Query(None, min_length=1, max_length=2048)):
|
|
return store.list_chats(user.id, limit, cursor)
|
|
|
|
|
|
@app.get('/api/v1/chats/{chat_id}', response_model=Chat)
|
|
def chat(chat_id: UUID, user: User = Depends(require_user)):
|
|
return store.get_chat(str(chat_id), user.id)
|
|
|
|
|
|
@app.post('/api/v1/chats/{chat_id}/messages', status_code=201, response_model=Message)
|
|
def send(request: Request, chat_id: UUID, data: CreateMessage, user: User = Depends(require_user)):
|
|
keys = request.headers.getlist("Idempotency-Key")
|
|
if len(keys) != 1 or not IDEMPOTENCY_KEY.fullmatch(keys[0]):
|
|
raise ApiError(400, "invalid_request", "Требуется корректный Idempotency-Key")
|
|
return store.create_message(str(chat_id), user.id, request.method, keys[0], data.text)
|
|
|
|
|
|
@app.get('/api/v1/chats/{chat_id}/messages', response_model=MessagePage)
|
|
def history(chat_id: UUID, user: User = Depends(require_user), limit: int = Query(50, ge=1, le=100), cursor: str | None = Query(None, min_length=1, max_length=2048)):
|
|
return store.list_messages(str(chat_id), user.id, limit, cursor)
|