forked from mtusi2026/mtusi2026lab2
Complete lab
This commit is contained in:
+68
@@ -0,0 +1,68 @@
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerificationError
|
||||
from redis import Redis
|
||||
|
||||
from .errors import APIError
|
||||
|
||||
password_hasher = PasswordHasher()
|
||||
dummy_hash = password_hasher.hash(secrets.token_urlsafe(32))
|
||||
|
||||
|
||||
def verify_password(encoded, password):
|
||||
try:
|
||||
return password_hasher.verify(encoded or dummy_hash, password) and encoded is not None
|
||||
except VerificationError:
|
||||
return False
|
||||
|
||||
|
||||
def unauthorized():
|
||||
return APIError(401, 'unauthorized', 'Нет действительной идентификации')
|
||||
|
||||
|
||||
class Sessions:
|
||||
def __init__(self):
|
||||
self.client = Redis.from_url(
|
||||
os.getenv('REDIS_URL', 'redis://redis:6379/0'), decode_responses=True,
|
||||
socket_connect_timeout=1, socket_timeout=1, max_connections=20,
|
||||
retry_on_timeout=False,
|
||||
)
|
||||
self.ttl = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
|
||||
if self.ttl < 1:
|
||||
raise ValueError('SESSION_TTL_SECONDS must be positive')
|
||||
|
||||
@staticmethod
|
||||
def key(token):
|
||||
if not re.fullmatch(r'[A-Za-z0-9_-]{43}', token):
|
||||
raise unauthorized()
|
||||
return 'session:' + hashlib.sha256(token.encode('ascii')).hexdigest()
|
||||
|
||||
def create(self, user):
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires = datetime.now(timezone.utc) + timedelta(seconds=self.ttl)
|
||||
expires_at = expires.isoformat(timespec='microseconds').replace('+00:00', 'Z')
|
||||
self.client.set(self.key(token), json.dumps({'user_id': user['id'], 'expires_at': expires_at}),
|
||||
pxat=int(expires.timestamp() * 1000))
|
||||
return {'token': token, 'token_type': 'Bearer', 'expires_at': expires_at, 'user': user}
|
||||
|
||||
def user_id(self, token):
|
||||
raw = self.client.get(self.key(token))
|
||||
if raw is None:
|
||||
raise unauthorized()
|
||||
session = json.loads(raw)
|
||||
if datetime.fromisoformat(session['expires_at'].replace('Z', '+00:00')) <= datetime.now(timezone.utc):
|
||||
raise unauthorized()
|
||||
return session['user_id']
|
||||
|
||||
def delete(self, token):
|
||||
if not self.client.delete(self.key(token)):
|
||||
raise unauthorized()
|
||||
|
||||
|
||||
sessions = Sessions()
|
||||
@@ -0,0 +1,40 @@
|
||||
"""History pages are disposable; PostgreSQL owns both data and their version."""
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
|
||||
from redis.exceptions import RedisError
|
||||
|
||||
from .auth import sessions
|
||||
|
||||
|
||||
class HistoryCache:
|
||||
def __init__(self, client, ttl=30, prefix='history'):
|
||||
self.client = client
|
||||
self.ttl = ttl
|
||||
self.prefix = prefix
|
||||
if ttl < 1:
|
||||
raise ValueError('CACHE_TTL_SECONDS must be positive')
|
||||
|
||||
def key(self, chat_id, version, limit, after):
|
||||
page = json.dumps([limit, after], separators=(',', ':'))
|
||||
digest = hashlib.sha256(page.encode()).hexdigest()
|
||||
return f'{self.prefix}:{chat_id}:{version}:{digest}'
|
||||
|
||||
def get_or_load(self, chat_id, version, limit, after, load):
|
||||
key = self.key(chat_id, version, limit, after)
|
||||
try:
|
||||
cached = self.client.get(key)
|
||||
except RedisError:
|
||||
return load()
|
||||
if cached is not None:
|
||||
return json.loads(cached)
|
||||
page = load()
|
||||
try:
|
||||
self.client.set(key, json.dumps(page, ensure_ascii=False), ex=self.ttl)
|
||||
except RedisError:
|
||||
pass
|
||||
return page
|
||||
|
||||
|
||||
history_cache = HistoryCache(sessions.client, int(os.getenv('CACHE_TTL_SECONDS', '30')))
|
||||
@@ -0,0 +1,51 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from sqlalchemy import create_engine, func, insert, select
|
||||
from sqlalchemy.engine import URL, make_url
|
||||
|
||||
from .models import SchemaMigration
|
||||
|
||||
|
||||
def database_url():
|
||||
if os.getenv('DATABASE_URL'):
|
||||
url = make_url(os.environ['DATABASE_URL'])
|
||||
if url.drivername in ('postgres', 'postgresql'):
|
||||
url = url.set(drivername='postgresql+psycopg')
|
||||
if url.drivername != 'postgresql+psycopg':
|
||||
raise ValueError('DATABASE_URL must use PostgreSQL with psycopg')
|
||||
return url
|
||||
return URL.create(
|
||||
'postgresql+psycopg', host=os.getenv('POSTGRES_HOST', 'postgres'),
|
||||
database=os.getenv('POSTGRES_DB', 'messenger'),
|
||||
username=os.getenv('POSTGRES_USER', 'messenger'),
|
||||
password=os.environ['POSTGRES_PASSWORD'],
|
||||
)
|
||||
|
||||
|
||||
def create_db_engine():
|
||||
return create_engine(
|
||||
database_url(), pool_size=10, max_overflow=0, pool_timeout=2, pool_pre_ping=True,
|
||||
connect_args={'connect_timeout': 2,
|
||||
'options': '-c statement_timeout=3000 -c lock_timeout=2000'},
|
||||
)
|
||||
|
||||
|
||||
def migrate(engine):
|
||||
with engine.begin() as conn:
|
||||
conn.execute(select(func.pg_advisory_xact_lock(202602)))
|
||||
SchemaMigration.__table__.create(conn, checkfirst=True)
|
||||
applied = set(conn.scalars(select(SchemaMigration.version)))
|
||||
for path in sorted((Path(__file__).resolve().parents[1] / 'migrations').glob('*.sql')):
|
||||
if path.name not in applied:
|
||||
conn.exec_driver_sql(path.read_text(encoding='utf-8'))
|
||||
conn.execute(insert(SchemaMigration).values(version=path.name))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
engine = create_db_engine()
|
||||
try:
|
||||
migrate(engine)
|
||||
print('Migrations applied')
|
||||
finally:
|
||||
engine.dispose()
|
||||
+14
-10
@@ -1,7 +1,8 @@
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import Header, Query
|
||||
from fastapi import Depends, Header, Query
|
||||
|
||||
from .auth import sessions, unauthorized
|
||||
from .errors import APIError
|
||||
from .store import store
|
||||
|
||||
@@ -16,12 +17,15 @@ def page_limit(limit: str = Query(default="50")) -> int:
|
||||
|
||||
|
||||
|
||||
def current_user(x_user_id: Optional[str] = Header(default=None, alias="X-User-Id")) -> dict:
|
||||
if not x_user_id:
|
||||
raise APIError(401, "unauthorized", "Нет действительной идентификации")
|
||||
try:
|
||||
return store.require_user(x_user_id)
|
||||
except APIError as exc:
|
||||
if exc.status_code == 400:
|
||||
raise APIError(401, "unauthorized", "Нет действительной идентификации") from exc
|
||||
raise
|
||||
def bearer_token(authorization: Optional[str] = Header(default=None)) -> str:
|
||||
parts = (authorization or '').split()
|
||||
if len(parts) != 2 or parts[0].lower() != 'bearer':
|
||||
raise unauthorized()
|
||||
return parts[1]
|
||||
|
||||
|
||||
def current_user(token: str = Depends(bearer_token)) -> dict:
|
||||
user = store.get_user(sessions.user_id(token))
|
||||
if user is None:
|
||||
raise unauthorized()
|
||||
return user
|
||||
|
||||
@@ -30,9 +30,18 @@ def api_error_handler(request: Request, exc: APIError) -> JSONResponse:
|
||||
response = error_response(request, exc.status_code, exc.code, exc.message)
|
||||
if exc.status_code == 429:
|
||||
response.headers['Retry-After'] = '1'
|
||||
if exc.status_code == 401:
|
||||
response.headers['WWW-Authenticate'] = (
|
||||
'Basic realm="messenger", charset="UTF-8"'
|
||||
if request.url.path == '/api/v1/auth/sessions' else 'Bearer realm="messenger"'
|
||||
)
|
||||
return response
|
||||
|
||||
|
||||
def dependency_error_handler(request: Request, exc: Exception) -> JSONResponse:
|
||||
return error_response(request, 503, 'unavailable', 'Хранилище временно недоступно')
|
||||
|
||||
|
||||
def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
|
||||
return error_response(request, 400, "invalid_request", "Неверный запрос")
|
||||
|
||||
|
||||
+27
-2
@@ -1,22 +1,47 @@
|
||||
from fastapi import FastAPI
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from starlette.exceptions import HTTPException
|
||||
from contextlib import asynccontextmanager
|
||||
from sqlalchemy.exc import OperationalError, InterfaceError, TimeoutError as PoolTimeout
|
||||
from sqlalchemy.orm import sessionmaker
|
||||
from redis.exceptions import RedisError
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
|
||||
from .errors import APIError, api_error_handler, validation_error_handler, http_error_handler, internal_error_handler
|
||||
from .errors import APIError, api_error_handler, validation_error_handler, http_error_handler, internal_error_handler, dependency_error_handler
|
||||
from .database import create_db_engine, migrate
|
||||
from .store import store
|
||||
from .auth import sessions
|
||||
from .middleware import RequestIdMiddleware
|
||||
from .limits import ResourceLimitMiddleware
|
||||
from .routers.health import router as health_router
|
||||
from .routers.users import router as users_router
|
||||
from .routers.chats import router as chats_router
|
||||
from .routers.auth import router as auth_router
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger")
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app):
|
||||
engine = create_db_engine()
|
||||
try:
|
||||
await run_in_threadpool(migrate, engine)
|
||||
store.sessions = sessionmaker(engine, expire_on_commit=False)
|
||||
yield
|
||||
finally:
|
||||
engine.dispose()
|
||||
sessions.client.close()
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger", lifespan=lifespan)
|
||||
app.add_middleware(ResourceLimitMiddleware)
|
||||
app.add_middleware(RequestIdMiddleware)
|
||||
app.add_exception_handler(APIError, api_error_handler)
|
||||
app.add_exception_handler(RequestValidationError, validation_error_handler)
|
||||
app.add_exception_handler(HTTPException, http_error_handler)
|
||||
app.add_exception_handler(Exception, internal_error_handler)
|
||||
for error in (OperationalError, InterfaceError, PoolTimeout, RedisError):
|
||||
app.add_exception_handler(error, dependency_error_handler)
|
||||
|
||||
app.include_router(health_router)
|
||||
app.include_router(users_router)
|
||||
app.include_router(chats_router)
|
||||
app.include_router(auth_router)
|
||||
|
||||
+3
-1
@@ -9,7 +9,9 @@ class RequestIdMiddleware(BaseHTTPMiddleware):
|
||||
request_id = request.headers.get("X-Request-Id", "").strip() or str(uuid4())
|
||||
request.state.request_id = request_id
|
||||
|
||||
if request.method in {"POST", "PUT", "PATCH"} and request.url.path.startswith("/api/"):
|
||||
if (request.method in {"POST", "PUT", "PATCH"}
|
||||
and request.url.path.startswith("/api/")
|
||||
and request.url.path != '/api/v1/auth/sessions'):
|
||||
content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
|
||||
if content_type != "application/json":
|
||||
response = JSONResponse(
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
from datetime import datetime
|
||||
from uuid import uuid4
|
||||
|
||||
from sqlalchemy import BigInteger, CheckConstraint, DateTime, ForeignKey, Index, Text, Uuid, func
|
||||
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
|
||||
|
||||
|
||||
class Base(DeclarativeBase):
|
||||
pass
|
||||
|
||||
|
||||
class User(Base):
|
||||
__tablename__ = 'users'
|
||||
__table_args__ = (
|
||||
CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'"),
|
||||
CheckConstraint('char_length(display_name) BETWEEN 1 AND 100'),
|
||||
)
|
||||
id: Mapped[str] = mapped_column(Uuid(as_uuid=False), primary_key=True, default=lambda: str(uuid4()))
|
||||
username: Mapped[str] = mapped_column(Text, unique=True)
|
||||
display_name: Mapped[str] = mapped_column(Text)
|
||||
password_hash: Mapped[str] = mapped_column(Text)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.clock_timestamp())
|
||||
|
||||
|
||||
class Chat(Base):
|
||||
__tablename__ = 'chats'
|
||||
__table_args__ = (
|
||||
CheckConstraint('char_length(title) BETWEEN 1 AND 100'),
|
||||
Index('chats_order_idx', 'created_at', 'id'),
|
||||
)
|
||||
id: Mapped[str] = mapped_column(Uuid(as_uuid=False), primary_key=True, default=lambda: str(uuid4()))
|
||||
title: Mapped[str] = mapped_column(Text)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.clock_timestamp())
|
||||
history_version: Mapped[int] = mapped_column(BigInteger, server_default='0')
|
||||
|
||||
|
||||
class ChatMember(Base):
|
||||
__tablename__ = 'chat_members'
|
||||
__table_args__ = (Index('chat_members_user_idx', 'user_id', 'chat_id'),)
|
||||
chat_id: Mapped[str] = mapped_column(Uuid(as_uuid=False), ForeignKey('chats.id', ondelete='CASCADE'), primary_key=True)
|
||||
user_id: Mapped[str] = mapped_column(Uuid(as_uuid=False), ForeignKey('users.id'), primary_key=True)
|
||||
|
||||
|
||||
class Message(Base):
|
||||
__tablename__ = 'messages'
|
||||
__table_args__ = (
|
||||
CheckConstraint('char_length(text) BETWEEN 1 AND 4000'),
|
||||
Index('messages_history_idx', 'chat_id', 'created_at', 'id'),
|
||||
)
|
||||
id: Mapped[str] = mapped_column(Uuid(as_uuid=False), primary_key=True, default=lambda: str(uuid4()))
|
||||
chat_id: Mapped[str] = mapped_column(Uuid(as_uuid=False), ForeignKey('chats.id', ondelete='CASCADE'))
|
||||
sender_id: Mapped[str] = mapped_column(Uuid(as_uuid=False), ForeignKey('users.id'))
|
||||
text: Mapped[str] = mapped_column(Text)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.clock_timestamp())
|
||||
|
||||
|
||||
class SchemaMigration(Base):
|
||||
__tablename__ = 'schema_migrations'
|
||||
version: Mapped[str] = mapped_column(Text, primary_key=True)
|
||||
applied_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=True)
|
||||
@@ -0,0 +1,34 @@
|
||||
import base64
|
||||
|
||||
from fastapi import APIRouter, Depends, Header, Request, Response
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
|
||||
from ..auth import sessions, unauthorized
|
||||
from ..dependencies import bearer_token, current_user
|
||||
from ..errors import APIError
|
||||
from ..store import store
|
||||
|
||||
router = APIRouter(prefix='/api/v1/auth/sessions', tags=['auth'])
|
||||
|
||||
|
||||
@router.post('', status_code=201)
|
||||
async def create_session(request: Request, authorization: str = Header(default='')):
|
||||
if await request.body():
|
||||
raise APIError(400, 'invalid_request', 'Вход не принимает тело запроса')
|
||||
try:
|
||||
scheme, encoded = authorization.split()
|
||||
if scheme.lower() != 'basic':
|
||||
raise ValueError()
|
||||
username, password = base64.b64decode(encoded, validate=True).decode('utf-8').split(':', 1)
|
||||
if not username.isascii() or not 12 <= len(password) <= 128 or '\x00' in username:
|
||||
raise ValueError()
|
||||
except (ValueError, UnicodeError):
|
||||
raise unauthorized() from None
|
||||
user = await run_in_threadpool(store.login, username, password)
|
||||
return await run_in_threadpool(sessions.create, user)
|
||||
|
||||
|
||||
@router.delete('/current', status_code=204)
|
||||
def logout(token: str = Depends(bearer_token), user: dict = Depends(current_user)):
|
||||
sessions.delete(token)
|
||||
return Response(status_code=204)
|
||||
@@ -1,6 +1,9 @@
|
||||
from fastapi import APIRouter
|
||||
from sqlalchemy import select
|
||||
|
||||
from ..schemas.common import Health
|
||||
from ..auth import sessions
|
||||
from ..store import store
|
||||
|
||||
router = APIRouter(prefix='/health')
|
||||
|
||||
@@ -12,4 +15,7 @@ def health_live():
|
||||
|
||||
@router.get("/ready", response_model=Health)
|
||||
def health_ready():
|
||||
with store.sessions() as session:
|
||||
session.execute(select(1))
|
||||
sessions.client.ping()
|
||||
return {"status": "ok"}
|
||||
|
||||
@@ -11,7 +11,7 @@ router = APIRouter(prefix="/api/v1/users", tags=["users"])
|
||||
|
||||
@router.post("", response_model=User, status_code=status.HTTP_201_CREATED)
|
||||
def create_user(payload: CreateUser):
|
||||
return store.create_user(payload.username, payload.display_name)
|
||||
return store.create_user(payload.username, payload.display_name, payload.password)
|
||||
|
||||
|
||||
@router.get("/me", response_model=User)
|
||||
|
||||
@@ -1,9 +1,17 @@
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
from pydantic import BaseModel, ConfigDict, field_validator
|
||||
|
||||
|
||||
class ContractModel(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
@field_validator('*')
|
||||
def validate_text_encoding(cls, value, info):
|
||||
if isinstance(value, str):
|
||||
value.encode('utf-8')
|
||||
if info.field_name != 'password' and '\x00' in value:
|
||||
raise ValueError('NUL is not supported in PostgreSQL text')
|
||||
return value
|
||||
|
||||
|
||||
class Health(ContractModel):
|
||||
status: str
|
||||
|
||||
@@ -12,6 +12,7 @@ USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
|
||||
class CreateUser(ContractModel):
|
||||
username: StrictStr
|
||||
display_name: StrictStr = Field(min_length=1, max_length=100)
|
||||
password: StrictStr = Field(min_length=12, max_length=128)
|
||||
|
||||
@field_validator("username")
|
||||
def validate_username(cls, value):
|
||||
|
||||
+139
-150
@@ -1,180 +1,169 @@
|
||||
import base64
|
||||
import json
|
||||
import time
|
||||
from datetime import datetime, timezone
|
||||
from threading import RLock
|
||||
from typing import Optional, Tuple
|
||||
from uuid import UUID, uuid4
|
||||
from typing import Tuple
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy import select, tuple_, update
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
|
||||
from .auth import password_hasher, verify_password, unauthorized
|
||||
from .errors import APIError
|
||||
from .limits import limits
|
||||
from .cache import history_cache
|
||||
from .models import User, Chat, ChatMember, Message
|
||||
|
||||
|
||||
def utc_now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
|
||||
|
||||
def ensure_uuid(value: str) -> str:
|
||||
def ensure_uuid(value):
|
||||
try:
|
||||
if not isinstance(value, str):
|
||||
raise ValueError("UUID must be a string")
|
||||
raise ValueError()
|
||||
return str(UUID(value))
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise APIError(400, "invalid_request", "Неверный UUID") from exc
|
||||
raise APIError(400, 'invalid_request', 'Неверный UUID') from exc
|
||||
|
||||
|
||||
class InMemoryStore:
|
||||
def __init__(self, settings=limits):
|
||||
self.settings = settings
|
||||
self._lock = RLock()
|
||||
self._users = {}
|
||||
self._usernames = set()
|
||||
self._chats = {}
|
||||
self._messages = {}
|
||||
self._message_count = 0
|
||||
self._text_bytes = 0
|
||||
self._tokens = float(settings.message_burst)
|
||||
self._refilled_at = time.monotonic()
|
||||
def serialize(model, *fields):
|
||||
if model is None:
|
||||
return None
|
||||
result = {}
|
||||
for field in fields:
|
||||
value = getattr(model, field)
|
||||
if isinstance(value, datetime):
|
||||
value = value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
|
||||
result[field] = value
|
||||
return result
|
||||
|
||||
def create_user(self, username: str, display_name: str) -> dict:
|
||||
with self._lock:
|
||||
if username in self._usernames:
|
||||
raise APIError(409, "conflict", "Имя пользователя уже занято")
|
||||
if len(self._users) >= self.settings.max_users:
|
||||
raise APIError(503, 'unavailable', 'Достигнут лимит пользователей')
|
||||
|
||||
user = {
|
||||
"id": str(uuid4()),
|
||||
"username": username,
|
||||
"display_name": display_name,
|
||||
"created_at": utc_now(),
|
||||
}
|
||||
self._users[user["id"]] = user
|
||||
self._usernames.add(username)
|
||||
return dict(user)
|
||||
USER_FIELDS = ('id', 'username', 'display_name', 'created_at')
|
||||
CHAT_FIELDS = ('id', 'title', 'created_at')
|
||||
MESSAGE_FIELDS = ('id', 'chat_id', 'sender_id', 'text', 'created_at')
|
||||
|
||||
def get_user(self, user_id: str) -> Optional[dict]:
|
||||
user_id = ensure_uuid(user_id)
|
||||
with self._lock:
|
||||
user = self._users.get(user_id)
|
||||
return dict(user) if user else None
|
||||
|
||||
def require_user(self, user_id: str) -> dict:
|
||||
user = self.get_user(user_id)
|
||||
if not user:
|
||||
raise APIError(401, "unauthorized", "Пользователь не авторизован")
|
||||
return user
|
||||
def after_condition(model, after):
|
||||
return tuple_(model.created_at, model.id) > (
|
||||
datetime.fromisoformat(after[0].replace('Z', '+00:00')), after[1])
|
||||
|
||||
def create_chat(self, actor_id: str, title: str, member_ids: list[str]) -> dict:
|
||||
actor_id = ensure_uuid(actor_id)
|
||||
normalized_members = [ensure_uuid(member_id) for member_id in member_ids]
|
||||
if len(normalized_members) != len(set(normalized_members)):
|
||||
raise APIError(400, "invalid_request", "Участники не должны повторяться")
|
||||
if actor_id not in normalized_members:
|
||||
raise APIError(400, "invalid_request", "Создатель должен быть участником чата")
|
||||
|
||||
with self._lock:
|
||||
if any(member_id not in self._users for member_id in normalized_members):
|
||||
raise APIError(400, "invalid_request", "Неизвестный участник")
|
||||
if len(self._chats) >= self.settings.max_chats:
|
||||
raise APIError(503, 'unavailable', 'Достигнут лимит чатов')
|
||||
def history_query(chat_id, limit, after):
|
||||
query = select(Message).where(Message.chat_id == chat_id)
|
||||
if after:
|
||||
query = query.where(after_condition(Message, after))
|
||||
return query.order_by(Message.created_at, Message.id).limit(limit + 1)
|
||||
|
||||
chat = {
|
||||
"id": str(uuid4()),
|
||||
"title": title,
|
||||
"member_ids": normalized_members,
|
||||
"created_at": utc_now(),
|
||||
}
|
||||
self._chats[chat["id"]] = chat
|
||||
self._messages[chat["id"]] = []
|
||||
return self._copy_chat(chat)
|
||||
|
||||
def get_chat_for_user(self, chat_id: str, actor_id: str) -> dict:
|
||||
chat_id = ensure_uuid(chat_id)
|
||||
actor_id = ensure_uuid(actor_id)
|
||||
with self._lock:
|
||||
chat = self._chats.get(chat_id)
|
||||
if not chat or actor_id not in chat["member_ids"]:
|
||||
raise APIError(404, "not_found", "Объект не найден")
|
||||
return self._copy_chat(chat)
|
||||
class PostgresStore:
|
||||
def __init__(self, cache=history_cache):
|
||||
self.sessions = None
|
||||
self.cache = cache
|
||||
|
||||
def list_chats(self, actor_id: str, limit: int, cursor: Optional[str]) -> dict:
|
||||
actor_id = ensure_uuid(actor_id)
|
||||
after = self._decode_cursor(cursor, "chats", actor_id) if cursor else None
|
||||
|
||||
with self._lock:
|
||||
chats = [
|
||||
self._copy_chat(chat)
|
||||
for chat in self._chats.values()
|
||||
if actor_id in chat["member_ids"]
|
||||
]
|
||||
chats.sort(key=lambda item: (item["created_at"], item["id"]))
|
||||
if after:
|
||||
chats = [chat for chat in chats if (chat["created_at"], chat["id"]) > after]
|
||||
|
||||
page = chats[:limit]
|
||||
next_cursor = None
|
||||
if len(chats) > limit and page:
|
||||
last = page[-1]
|
||||
next_cursor = self._encode_cursor("chats", actor_id, last["created_at"], last["id"])
|
||||
return {"items": page, "next_cursor": next_cursor}
|
||||
|
||||
def create_message(self, chat_id: str, actor_id: str, text: str) -> dict:
|
||||
chat = self.get_chat_for_user(chat_id, actor_id)
|
||||
def create_user(self, username, display_name, password):
|
||||
user = User(username=username, display_name=display_name, password_hash=password_hasher.hash(password))
|
||||
try:
|
||||
text_size = len(text.encode('utf-8'))
|
||||
except UnicodeEncodeError as exc:
|
||||
raise APIError(400, 'invalid_request', 'Некорректный Unicode') from exc
|
||||
with self._lock:
|
||||
if self._message_count >= self.settings.max_messages:
|
||||
raise APIError(503, 'unavailable', 'Достигнут лимит сообщений')
|
||||
if self._text_bytes + text_size > self.settings.max_text_bytes:
|
||||
raise APIError(503, 'unavailable', 'Достигнут лимит объёма текста')
|
||||
now = time.monotonic()
|
||||
self._tokens = min(self.settings.message_burst,
|
||||
self._tokens + (now - self._refilled_at) * self.settings.message_rate)
|
||||
self._refilled_at = now
|
||||
if self._tokens < 1:
|
||||
raise APIError(429, 'rate_limited', 'Слишком частая отправка сообщений')
|
||||
self._tokens -= 1
|
||||
message = {
|
||||
"id": str(uuid4()),
|
||||
"chat_id": chat["id"],
|
||||
"sender_id": ensure_uuid(actor_id),
|
||||
"text": text,
|
||||
"created_at": utc_now(),
|
||||
}
|
||||
self._messages[chat["id"]].append(message)
|
||||
self._message_count += 1
|
||||
self._text_bytes += text_size
|
||||
return dict(message)
|
||||
with self.sessions.begin() as session:
|
||||
session.add(user)
|
||||
session.flush()
|
||||
result = serialize(user, *USER_FIELDS)
|
||||
return result
|
||||
except IntegrityError as exc:
|
||||
if getattr(exc.orig, 'sqlstate', None) == '23505':
|
||||
raise APIError(409, 'conflict', 'Имя пользователя уже занято') from exc
|
||||
raise
|
||||
|
||||
def list_messages(self, chat_id: str, actor_id: str, limit: int, cursor: Optional[str]) -> dict:
|
||||
chat = self.get_chat_for_user(chat_id, actor_id)
|
||||
after = self._decode_cursor(cursor, "messages", chat["id"]) if cursor else None
|
||||
def get_user(self, user_id):
|
||||
with self.sessions() as session:
|
||||
return serialize(session.get(User, ensure_uuid(user_id)), *USER_FIELDS)
|
||||
|
||||
with self._lock:
|
||||
messages = [dict(message) for message in self._messages.get(chat["id"], [])]
|
||||
messages.sort(key=lambda item: (item["created_at"], item["id"]))
|
||||
if after:
|
||||
messages = [
|
||||
message
|
||||
for message in messages
|
||||
if (message["created_at"], message["id"]) > after
|
||||
]
|
||||
def login(self, username, password):
|
||||
with self.sessions() as session:
|
||||
user = session.scalar(select(User).where(User.username == username))
|
||||
encoded = user.password_hash if user else None
|
||||
result = serialize(user, *USER_FIELDS)
|
||||
if not verify_password(encoded, password):
|
||||
raise unauthorized()
|
||||
return result
|
||||
|
||||
page = messages[:limit]
|
||||
next_cursor = None
|
||||
if len(messages) > limit and page:
|
||||
last = page[-1]
|
||||
next_cursor = self._encode_cursor("messages", chat["id"], last["created_at"], last["id"])
|
||||
return {"items": page, "next_cursor": next_cursor}
|
||||
def create_chat(self, actor_id, title, member_ids):
|
||||
members = [ensure_uuid(member) for member in member_ids]
|
||||
if len(members) != len(set(members)) or actor_id not in members:
|
||||
raise APIError(400, 'invalid_request', 'Неверный список участников')
|
||||
try:
|
||||
with self.sessions.begin() as session:
|
||||
chat = Chat(title=title)
|
||||
session.add(chat)
|
||||
session.flush()
|
||||
session.add_all([ChatMember(chat_id=chat.id, user_id=member) for member in members])
|
||||
result = serialize(chat, *CHAT_FIELDS)
|
||||
result['member_ids'] = sorted(members)
|
||||
return result
|
||||
except IntegrityError as exc:
|
||||
if getattr(exc.orig, 'sqlstate', None) == '23503':
|
||||
raise APIError(400, 'invalid_request', 'Неизвестный участник') from exc
|
||||
raise
|
||||
|
||||
@staticmethod
|
||||
def _copy_chat(chat: dict) -> dict:
|
||||
copy = dict(chat)
|
||||
copy["member_ids"] = list(chat["member_ids"])
|
||||
return copy
|
||||
def _chat(session, chat_id, actor_id):
|
||||
chat = session.scalar(select(Chat).join(ChatMember).where(
|
||||
Chat.id == chat_id, ChatMember.user_id == actor_id))
|
||||
if chat is None:
|
||||
raise APIError(404, 'not_found', 'Объект не найден')
|
||||
return chat
|
||||
|
||||
@staticmethod
|
||||
def _members(session, chat):
|
||||
result = serialize(chat, *CHAT_FIELDS)
|
||||
result['member_ids'] = list(session.scalars(select(ChatMember.user_id).where(
|
||||
ChatMember.chat_id == chat.id).order_by(ChatMember.user_id)))
|
||||
return result
|
||||
|
||||
def get_chat_for_user(self, chat_id, actor_id):
|
||||
with self.sessions() as session:
|
||||
return self._members(session, self._chat(session, ensure_uuid(chat_id), actor_id))
|
||||
|
||||
def list_chats(self, actor_id, limit, cursor):
|
||||
after = self._decode_cursor(cursor, 'chats', actor_id) if cursor else None
|
||||
query = select(Chat).join(ChatMember).where(ChatMember.user_id == actor_id)
|
||||
if after:
|
||||
query = query.where(after_condition(Chat, after))
|
||||
query = query.order_by(Chat.created_at, Chat.id).limit(limit + 1)
|
||||
with self.sessions() as session:
|
||||
chats = list(session.scalars(query))
|
||||
items = [self._members(session, chat) for chat in chats[:limit]]
|
||||
return self._page(items, len(chats) > limit, 'chats', actor_id)
|
||||
|
||||
def create_message(self, chat_id, actor_id, text):
|
||||
chat_id = ensure_uuid(chat_id)
|
||||
with self.sessions.begin() as session:
|
||||
self._chat(session, chat_id, actor_id)
|
||||
session.execute(update(Chat).where(Chat.id == chat_id).values(
|
||||
history_version=Chat.history_version + 1))
|
||||
message = Message(chat_id=chat_id, sender_id=actor_id, text=text)
|
||||
session.add(message)
|
||||
session.flush()
|
||||
result = serialize(message, *MESSAGE_FIELDS)
|
||||
return result
|
||||
|
||||
def list_messages(self, chat_id, actor_id, limit, cursor):
|
||||
chat_id = ensure_uuid(chat_id)
|
||||
after = self._decode_cursor(cursor, 'messages', chat_id) if cursor else None
|
||||
with self.sessions() as session:
|
||||
version = self._chat(session, chat_id, actor_id).history_version
|
||||
return self.cache.get_or_load(
|
||||
chat_id, version, limit, after,
|
||||
lambda: self._load_messages(chat_id, limit, after),
|
||||
)
|
||||
|
||||
def _load_messages(self, chat_id, limit, after):
|
||||
with self.sessions() as session:
|
||||
messages = list(session.scalars(history_query(chat_id, limit, after)))
|
||||
items = [serialize(message, *MESSAGE_FIELDS) for message in messages[:limit]]
|
||||
return self._page(items, len(messages) > limit, 'messages', chat_id)
|
||||
|
||||
def _page(self, items, has_more, resource, owner_id):
|
||||
cursor = None
|
||||
if has_more:
|
||||
last = items[-1]
|
||||
cursor = self._encode_cursor(resource, owner_id, last['created_at'], last['id'])
|
||||
return {'items': items, 'next_cursor': cursor}
|
||||
|
||||
@staticmethod
|
||||
def _encode_cursor(resource: str, owner_id: str, created_at: str, item_id: str) -> str:
|
||||
@@ -215,4 +204,4 @@ class InMemoryStore:
|
||||
return created_at, item_id
|
||||
|
||||
|
||||
store = InMemoryStore()
|
||||
store = PostgresStore()
|
||||
|
||||
Reference in New Issue
Block a user