161 lines
6.3 KiB
Python
161 lines
6.3 KiB
Python
import hashlib
|
|
import logging
|
|
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.cache import profile
|
|
from src.config import SESSION_TTL
|
|
from src.db import connection, migrate, 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
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app):
|
|
# Startup happens before serving requests; migrations also work via python -m src.db.
|
|
anyio.to_thread.current_default_thread_limiter().total_tokens = 16
|
|
migrate()
|
|
pool.open()
|
|
pool.wait(timeout=10)
|
|
yield
|
|
pool.close()
|
|
|
|
|
|
app = FastAPI(title="MTUSI Messenger", version="1.2.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
|
|
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:
|
|
row = conn.execute("SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()", (digest,)).fetchone()
|
|
if row is None:
|
|
unauthorized()
|
|
user_id = str(row['user_id'])
|
|
user = profile(user_id, lambda: store.load_user(user_id))
|
|
if user is None:
|
|
unauthorized()
|
|
request.state.token_hash = digest
|
|
return User(**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(chat_id: UUID, data: CreateMessage, user: User = Depends(require_user)):
|
|
return store.create_message(str(chat_id), user.id, 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)
|