chore: setup project and copy lab2 code

This commit is contained in:
2026-10-28 23:21:31 +03:00
parent 0ab3a341aa
commit 7fd38cf2e2
21 changed files with 1344 additions and 0 deletions
+27
View File
@@ -0,0 +1,27 @@
# syntax=docker/dockerfile:1.7
FROM python:3.11.9-slim AS builder
WORKDIR /build
COPY requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt
FROM python:3.11.9-slim
RUN useradd -m -u 10001 appuser
WORKDIR /app
COPY --from=builder /root/.local /home/appuser/.local
COPY app ./app
COPY migrations ./migrations
COPY alembic.ini .
ENV PATH=/home/appuser/.local/bin:$PATH \
PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1
RUN chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=30s --timeout=3s --start-period=20s --retries=5 \
CMD python -c "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status==200 else 1)"
CMD ["sh", "-c", "alembic upgrade head && python -m app.main"]
+114
View File
@@ -0,0 +1,114 @@
# A generic, single database configuration.
[alembic]
# path to migration scripts
script_location = migrations
# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
# Uncomment the line below if you want the files to be prepended with date and time
# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
# sys.path path, will be prepended to sys.path if present.
# defaults to the current working directory.
prepend_sys_path = .
# timezone to use when rendering the date within the migration file
# as well as the filename.
# If specified, requires the python>=3.9 or backports.zoneinfo library.
# Any required deps can installed by adding `alembic[tz]` to the pip requirements
# string value is passed to ZoneInfo()
# leave blank for localtime
# timezone =
# max length of characters to apply to the
# "slug" field
# truncate_slug_length = 40
# set to 'true' to run the environment during
# the 'revision' command, regardless of autogenerate
# revision_environment = false
# set to 'true' to allow .pyc and .pyo files without
# a source .py file to be detected as revisions in the
# versions/ directory
# sourceless = false
# version location specification; This defaults
# to migrations/versions. When using multiple version
# directories, initial revisions must be specified with --version-path.
# The path separator used here should be the separator specified by "version_path_separator" below.
# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions
# version path separator; As mentioned above, this is the character used to split
# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
# Valid values for version_path_separator are:
#
# version_path_separator = :
# version_path_separator = ;
# version_path_separator = space
version_path_separator = os # Use os.pathsep. Default configuration used for new projects.
# set to 'true' to search source files recursively
# in each "version_locations" directory
# new in Alembic version 1.10
# recursive_version_locations = false
# the output encoding used when revision files
# are written from script.py.mako
# output_encoding = utf-8
sqlalchemy.url = driver://user:pass@localhost/dbname
[post_write_hooks]
# post_write_hooks defines scripts or Python functions that are run
# on newly generated revision scripts. See the documentation for further
# detail and examples
# format using "black" - use the console_scripts runner, against the "black" entrypoint
# hooks = black
# black.type = console_scripts
# black.entrypoint = black
# black.options = -l 79 REVISION_SCRIPT_FILENAME
# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
# hooks = ruff
# ruff.type = exec
# ruff.executable = %(here)s/.venv/bin/ruff
# ruff.options = --fix REVISION_SCRIPT_FILENAME
# Logging configuration
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
qualname =
[logger_sqlalchemy]
level = WARN
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
View File
+85
View File
@@ -0,0 +1,85 @@
import hashlib
import os
import secrets
from datetime import datetime, timezone
from uuid import UUID
import bcrypt
from fastapi import Depends, Header, HTTPException
from sqlalchemy import delete, select
from sqlalchemy.ext.asyncio import AsyncSession
from .db.models import SessionRow, User
from .db.session import get_db
import redis.asyncio as redis
redis_client = redis.from_url(os.getenv("REDIS_URL", "redis://redis:6379/0"))
SESSION_TTL = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
def _prehash(password: str) -> bytes:
# bcrypt работает с ≤72 байт, SHA-256 даёт 32 байта и снимает ограничение
return hashlib.sha256(password.encode("utf-8")).hexdigest().encode("ascii")
def hash_password(password: str) -> str:
return bcrypt.hashpw(_prehash(password), bcrypt.gensalt(rounds=12)).decode("ascii")
def verify_password(password: str, password_hash: str) -> bool:
try:
return bcrypt.checkpw(_prehash(password), password_hash.encode("ascii"))
except ValueError:
return False
def generate_token() -> str:
return secrets.token_urlsafe(32)
def hash_token(token: str) -> str:
return hashlib.sha256(token.encode("ascii")).hexdigest()
def _unauthorized_bearer() -> HTTPException:
return HTTPException(
status_code=401,
detail="Unauthorized",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
async def create_session(user_id: str) -> str:
token = generate_token()
await redis_client.setex(
f"session:{hash_token(token)}", SESSION_TTL, str(user_id)
)
return token
async def get_current_user(
authorization: str | None = Header(None, alias="Authorization"),
db: AsyncSession = Depends(get_db),
) -> User:
if not authorization or not authorization.startswith("Bearer "):
raise _unauthorized_bearer()
token = authorization[7:]
token_hash = hash_token(token)
user_id_raw = await redis_client.get(f"session:{token_hash}")
if user_id_raw is None:
raise _unauthorized_bearer()
user = await db.get(User, UUID(user_id_raw.decode()))
if user is None:
raise _unauthorized_bearer()
return user
async def revoke_current_session(authorization: str, db: AsyncSession) -> None:
if not authorization or not authorization.startswith("Bearer "):
raise _unauthorized_bearer()
token = authorization[7:]
deleted = await redis_client.delete(f"session:{hash_token(token)}")
if deleted == 0:
raise _unauthorized_bearer()
View File
+5
View File
@@ -0,0 +1,5 @@
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
+100
View File
@@ -0,0 +1,100 @@
from datetime import datetime, timezone
from uuid import UUID, uuid4
from sqlalchemy import DateTime, ForeignKey, Index, String, Text
from sqlalchemy.dialects.postgresql import UUID as PG_UUID
from sqlalchemy.orm import Mapped, mapped_column
from .base import Base
def _now() -> datetime:
return datetime.now(timezone.utc)
class User(Base):
__tablename__ = "users"
id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), primary_key=True, default=uuid4
)
username: Mapped[str] = mapped_column(
String(32), unique=True, nullable=False, index=True
)
display_name: Mapped[str] = mapped_column(String(100), nullable=False)
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), default=_now, nullable=False
)
class Chat(Base):
__tablename__ = "chats"
id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), primary_key=True, default=uuid4
)
title: Mapped[str] = mapped_column(String(100), nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), default=_now, nullable=False
)
__table_args__ = (Index("idx_chats_created_id", "created_at", "id"),)
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
primary_key=True,
)
user_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
primary_key=True,
)
__table_args__ = (Index("idx_chat_members_user", "user_id", "chat_id"),)
class Message(Base):
__tablename__ = "messages"
id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), primary_key=True, default=uuid4
)
chat_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
nullable=False,
)
sender_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), ForeignKey("users.id"), nullable=False
)
text: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), default=_now, nullable=False
)
__table_args__ = (
Index("idx_messages_chat_created_id", "chat_id", "created_at", "id"),
)
class SessionRow(Base):
__tablename__ = "sessions"
id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True), primary_key=True, default=uuid4
)
user_id: Mapped[UUID] = mapped_column(
PG_UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
nullable=False,
)
token_hash: Mapped[str] = mapped_column(
String(64), unique=True, nullable=False, index=True
)
expires_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), nullable=False, index=True
)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), default=_now, nullable=False
)
+31
View File
@@ -0,0 +1,31 @@
import os
from sqlalchemy.ext.asyncio import (
AsyncSession,
async_sessionmaker,
create_async_engine,
)
DATABASE_URL = os.getenv(
"DATABASE_URL",
"postgresql+asyncpg://messenger:strongpassword@localhost:5432/messenger",
)
engine = create_async_engine(
DATABASE_URL,
pool_size=10,
max_overflow=20,
pool_timeout=5,
pool_recycle=1800,
pool_pre_ping=True,
connect_args={"timeout": 5, "command_timeout": 10},
)
async_session = async_sessionmaker(
engine, class_=AsyncSession, expire_on_commit=False
)
async def get_db() -> AsyncSession:
async with async_session() as session:
yield session
+290
View File
@@ -0,0 +1,290 @@
import os
import uuid
from contextvars import ContextVar
from datetime import datetime, timedelta, timezone
from typing import Optional
from uuid import UUID
from fastapi import Depends, FastAPI, Header, HTTPException, Query, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from sqlalchemy import text
from sqlalchemy.ext.asyncio import AsyncSession
from starlette.middleware.base import BaseHTTPMiddleware
from .auth import (
SESSION_TTL,
create_session,
generate_token,
get_current_user,
hash_password,
hash_token,
revoke_current_session,
verify_password,
)
from .db.models import SessionRow, User
from .db.session import get_db
from .models import CreateChat, CreateMessage, CreateUser
from .repositories import chats as chats_repo
from .repositories import messages as messages_repo
from .repositories import users as users_repo
request_id_var: ContextVar[str] = ContextVar("request_id", default="")
_HTTP_CODES = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
500: "internal_error",
}
def err_json(status: int, code: str, message: str) -> JSONResponse:
return JSONResponse(
status_code=status,
content={
"error": {
"code": code,
"message": message,
"request_id": request_id_var.get(),
}
},
)
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next):
rid = request.headers.get("X-Request-Id") or uuid.uuid4().hex
request_id_var.set(rid)
response = await call_next(request)
response.headers["X-Request-Id"] = rid
return response
app = FastAPI(title="MTUSI Messenger — lab2")
app.add_middleware(RequestIdMiddleware)
security = HTTPBasic(auto_error=False)
@app.exception_handler(RequestValidationError)
async def _validation(request: Request, exc: RequestValidationError):
return err_json(400, "invalid_request", "Validation error")
@app.exception_handler(HTTPException)
async def _http(request: Request, exc: HTTPException):
code = _HTTP_CODES.get(exc.status_code, "internal_error")
detail = exc.detail if isinstance(exc.detail, str) else "Error"
resp = err_json(exc.status_code, code, detail)
if exc.headers:
for k, v in exc.headers.items():
resp.headers[k] = v
return resp
@app.exception_handler(Exception)
async def _generic(request: Request, exc: Exception):
return err_json(500, "internal_error", "Internal server error")
def _iso_z(dt: datetime) -> str:
return dt.isoformat().replace("+00:00", "Z")
def _user_json(u: User) -> dict:
return {
"id": str(u.id),
"username": u.username,
"display_name": u.display_name,
"created_at": _iso_z(u.created_at),
}
def _chat_json(chat, member_ids: list[str]) -> dict:
return {
"id": str(chat.id),
"title": chat.title,
"member_ids": member_ids,
"created_at": _iso_z(chat.created_at),
}
def _msg_json(m) -> dict:
return {
"id": str(m.id),
"chat_id": str(m.chat_id),
"sender_id": str(m.sender_id),
"text": m.text,
"created_at": _iso_z(m.created_at),
}
# ---------- health ----------
@app.get("/health/live")
def live():
return {"status": "ok"}
@app.get("/health/ready")
async def ready(db: AsyncSession = Depends(get_db)):
try:
await db.execute(text("SELECT 1"))
except Exception:
return err_json(503, "unavailable", "Database unavailable")
return {"status": "ok"}
# ---------- users ----------
@app.post("/api/v1/users", status_code=201)
async def register(body: CreateUser, db: AsyncSession = Depends(get_db)):
existing = await users_repo.get_by_username(db, body.username)
if existing is not None:
raise HTTPException(409, "Username already exists")
try:
user = await users_repo.create(
db, body.username, body.display_name, hash_password(body.password)
)
except Exception:
raise HTTPException(409, "Username already exists")
return _user_json(user)
# ---------- sessions ----------
@app.post("/api/v1/auth/sessions", status_code=201)
async def login(
creds: Optional[HTTPBasicCredentials] = Depends(security),
db: AsyncSession = Depends(get_db),
):
basic_challenge = 'Basic realm="messenger", charset="UTF-8"'
if creds is None:
raise HTTPException(
status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": basic_challenge}
)
user = await users_repo.get_by_username(db, creds.username)
if user is None or not verify_password(creds.password, user.password_hash):
raise HTTPException(
status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": basic_challenge}
)
expires = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)
token = await create_session(str(user.id))
return {
"token": token,
"token_type": "Bearer",
"expires_at": _iso_z(expires),
"user": _user_json(user),
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(authorization: str = Header(...), db: AsyncSession = Depends(get_db)):
await revoke_current_session(authorization, db)
@app.get("/api/v1/users/me")
async def me(user: User = Depends(get_current_user)):
return _user_json(user)
# ---------- chats ----------
@app.post("/api/v1/chats", status_code=201)
async def create_chat(
body: CreateChat,
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
if user.id not in body.member_ids:
raise HTTPException(400, "Caller must be in member_ids")
try:
chat = await chats_repo.create_atomic(db, body.title, body.member_ids)
except ValueError:
raise HTTPException(404, "Member not found")
return _chat_json(chat, [str(x) for x in body.member_ids])
@app.get("/api/v1/chats")
async def list_chats(
user: User = Depends(get_current_user),
limit: int = Query(50, ge=1, le=100),
cursor: Optional[str] = Query(None, min_length=1),
db: AsyncSession = Depends(get_db),
):
parsed = None
if cursor is not None:
try:
c_created, c_id = cursor.split("|", 1)
parsed = (datetime.fromisoformat(c_created), UUID(c_id))
except Exception:
raise HTTPException(400, "Invalid cursor")
rows, next_cursor = await chats_repo.list_for_user(db, user.id, limit, parsed)
items = []
for chat in rows:
members = await chats_repo.list_member_ids(db, chat.id)
items.append(_chat_json(chat, [str(m) for m in members]))
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
return {"items": items, "next_cursor": nxt}
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(
chat_id: UUID,
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
members = await chats_repo.list_member_ids(db, chat.id)
return _chat_json(chat, [str(m) for m in members])
# ---------- messages ----------
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def post_message(
chat_id: UUID,
body: CreateMessage,
user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
msg = await messages_repo.create_and_invalidate(db, chat_id, user.id, body.text)
return _msg_json(msg)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(
chat_id: UUID,
user: User = Depends(get_current_user),
limit: int = Query(50, ge=1, le=100),
cursor: Optional[str] = Query(None, min_length=1),
db: AsyncSession = Depends(get_db),
):
chat = await chats_repo.get_if_member(db, chat_id, user.id)
if chat is None:
raise HTTPException(404, "Chat not found")
parsed = None
if cursor is not None:
try:
c_created, c_id = cursor.split("|", 1)
parsed = (datetime.fromisoformat(c_created), UUID(c_id))
except Exception:
raise HTTPException(400, "Invalid cursor")
rows, next_cursor, _cached = await messages_repo.list_page_cached(db, chat_id, limit, parsed)
nxt = f"{next_cursor[0].isoformat()}|{next_cursor[1]}" if next_cursor else None
return {"items": [_msg_json(m) for m in rows], "next_cursor": nxt}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("APP_PORT", "8080")))
+56
View File
@@ -0,0 +1,56 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
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=12, max_length=128)
@field_validator("display_name", "password")
@classmethod
def _not_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("must not be blank")
return v
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 _title_not_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("title must not be blank")
return v
@field_validator("member_ids")
@classmethod
def _unique_members(cls, v: list[UUID]) -> list[UUID]:
if len(set(v)) != len(v):
raise ValueError("duplicate member_ids")
return v
class CreateMessage(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def _text_not_blank(cls, v: str) -> str:
if not v.strip():
raise ValueError("text must not be blank")
return v
class SessionResponse(BaseModel):
token: str
token_type: str = "Bearer"
expires_at: str
user: dict
View File
+80
View File
@@ -0,0 +1,80 @@
from datetime import datetime
from uuid import UUID
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from ..db.models import Chat, ChatMember, User
async def create_atomic(
db: AsyncSession, title: str, member_ids: list[UUID]
) -> Chat:
found = (
(await db.execute(select(User.id).where(User.id.in_(member_ids))))
.scalars()
.all()
)
if len(set(found)) != len(set(member_ids)):
await db.rollback()
raise ValueError("member_not_found")
chat = Chat(title=title)
db.add(chat)
await db.flush()
for uid in member_ids:
db.add(ChatMember(chat_id=chat.id, user_id=uid))
try:
await db.commit()
except Exception:
await db.rollback()
raise
await db.refresh(chat)
return chat
async def get_if_member(
db: AsyncSession, chat_id: UUID, user_id: UUID
) -> Chat | None:
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
return (await db.execute(stmt)).scalar_one_or_none()
async def list_member_ids(db: AsyncSession, chat_id: UUID) -> list[UUID]:
stmt = select(ChatMember.user_id).where(ChatMember.chat_id == chat_id)
return list((await db.execute(stmt)).scalars().all())
async def list_for_user(
db: AsyncSession,
user_id: UUID,
limit: int,
cursor: tuple[datetime, UUID] | None,
) -> tuple[list[Chat], tuple[datetime, UUID] | None]:
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user_id)
.order_by(Chat.created_at.asc(), Chat.id.asc())
.limit(limit + 1)
)
if cursor is not None:
c_created, c_id = cursor
stmt = stmt.where(
(Chat.created_at > c_created)
| ((Chat.created_at == c_created) & (Chat.id > c_id))
)
rows = list((await db.execute(stmt)).scalars().all())
next_cursor = None
if len(rows) > limit:
rows = rows[:limit]
last = rows[-1]
next_cursor = (last.created_at, last.id)
return rows, next_cursor
+128
View File
@@ -0,0 +1,128 @@
import json
import os
from datetime import datetime
from types import SimpleNamespace
from uuid import UUID
import redis.asyncio as redis
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from ..db.models import Message
redis_client = redis.from_url(os.getenv("REDIS_URL", "redis://redis:6379/0"))
CACHE_TTL = 30
def _serialize(rows: list[Message], next_cursor):
return {
"items": [
{
"id": str(m.id),
"chat_id": str(m.chat_id),
"sender_id": str(m.sender_id),
"text": m.text,
"created_at": m.created_at.isoformat(),
}
for m in rows
],
"next_cursor": (
[next_cursor[0].isoformat(), str(next_cursor[1])] if next_cursor else None
),
}
def _deserialize(data: dict):
items = [
SimpleNamespace(
id=UUID(row["id"]),
chat_id=UUID(row["chat_id"]),
sender_id=UUID(row["sender_id"]),
text=row["text"],
created_at=datetime.fromisoformat(row["created_at"]),
)
for row in data["items"]
]
nc = data.get("next_cursor")
next_cursor = (datetime.fromisoformat(nc[0]), UUID(nc[1])) if nc else None
return items, next_cursor
async def create(
db: AsyncSession, chat_id: UUID, sender_id: UUID, text: str
) -> Message:
msg = Message(chat_id=chat_id, sender_id=sender_id, text=text)
db.add(msg)
await db.commit()
await db.refresh(msg)
return msg
async def create_and_invalidate(
db: AsyncSession, chat_id: UUID, sender_id: UUID, text: str
) -> Message:
msg = await create(db, chat_id, sender_id, text)
keys = [f"chat:{chat_id}:first_page:{n}" for n in (10, 20, 50)]
await redis_client.delete(*keys)
return msg
async def list_page(
db: AsyncSession,
chat_id: UUID,
limit: int,
cursor: tuple[datetime, UUID] | None,
) -> tuple[list[Message], tuple[datetime, UUID] | None]:
stmt = (
select(Message)
.where(Message.chat_id == chat_id)
.order_by(Message.created_at.asc(), Message.id.asc())
.limit(limit + 1)
)
if cursor is not None:
c_created, c_id = cursor
stmt = stmt.where(
(Message.created_at > c_created)
| ((Message.created_at == c_created) & (Message.id > c_id))
)
rows = list((await db.execute(stmt)).scalars().all())
next_cursor = None
if len(rows) > limit:
rows = rows[:limit]
last = rows[-1]
next_cursor = (last.created_at, last.id)
return rows, next_cursor
async def list_page_cached(
db: AsyncSession,
chat_id: UUID,
limit: int,
cursor: tuple[datetime, UUID] | None,
) -> tuple[list, tuple[datetime, UUID] | None, bool]:
"""Возвращает (rows, next_cursor, cached)."""
use_cache = cursor is None and limit <= 50
key = f"chat:{chat_id}:first_page:{limit}"
if use_cache:
raw = await redis_client.get(key)
if raw is not None:
try:
rows, next_cursor = _deserialize(json.loads(raw))
return rows, next_cursor, True
except Exception:
pass # повреждённый кэш — игнорируем и идём в БД
rows, next_cursor = await list_page(db, chat_id, limit, cursor)
if use_cache:
try:
payload = json.dumps(_serialize(rows, next_cursor))
await redis_client.setex(key, CACHE_TTL, payload)
print(f"CACHE SET OK: {key}", flush=True)
except Exception as e:
import traceback
traceback.print_exc()
print(f"CACHE SET FAILED: {type(e).__name__}: {e}", flush=True)
return rows, next_cursor, False
+28
View File
@@ -0,0 +1,28 @@
from uuid import UUID
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from ..db.models import User
async def get_by_username(db: AsyncSession, username: str) -> User | None:
return (
await db.execute(select(User).where(User.username == username))
).scalar_one_or_none()
async def get_by_id(db: AsyncSession, user_id: UUID) -> User | None:
return await db.get(User, user_id)
async def create(
db: AsyncSession, username: str, display_name: str, password_hash: str
) -> User:
user = User(
username=username, display_name=display_name, password_hash=password_hash
)
db.add(user)
await db.commit()
await db.refresh(user)
return user
+1
View File
@@ -0,0 +1 @@
Generic single-database configuration with an async dbapi.
+99
View File
@@ -0,0 +1,99 @@
import asyncio
from logging.config import fileConfig
from sqlalchemy import pool
from sqlalchemy.engine import Connection
from sqlalchemy.ext.asyncio import async_engine_from_config
from alembic import context
import os
from app.db import models # noqa: F401 — регистрирует таблицы
from app.db.base import Base
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Interpret the config file for Python logging.
# This line sets up loggers basically.
if config.config_file_name is not None:
fileConfig(config.config_file_name)
# add your model's MetaData object here
# for 'autogenerate' support
# from myapp import mymodel
# target_metadata = mymodel.Base.metadata
target_metadata = Base.metadata
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def run_migrations_offline() -> None:
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
"""
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def do_run_migrations(connection: Connection) -> None:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
async def run_async_migrations() -> None:
"""In this scenario we need to create an Engine
and associate a connection with the context.
"""
config.set_main_option(
"sqlalchemy.url",
os.getenv(
"DATABASE_URL",
"postgresql+asyncpg://messenger:strongpassword@localhost:5432/messenger",
),
)
connectable = async_engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
async with connectable.connect() as connection:
await connection.run_sync(do_run_migrations)
await connectable.dispose()
def run_migrations_online() -> None:
"""Run migrations in 'online' mode."""
asyncio.run(run_async_migrations())
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+26
View File
@@ -0,0 +1,26 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision: str = ${repr(up_revision)}
down_revision: Union[str, None] = ${repr(down_revision)}
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,85 @@
"""initial schema
Revision ID: 44ea9d3b68ac
Revises:
Create Date: 2026-10-01 02:42:35.498512
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '44ea9d3b68ac'
down_revision: Union[str, None] = None
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('chats',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('title', sa.String(length=100), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_index('idx_chats_created_id', 'chats', ['created_at', 'id'], unique=False)
op.create_table('users',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('username', sa.String(length=32), nullable=False),
sa.Column('display_name', sa.String(length=100), nullable=False),
sa.Column('password_hash', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
op.create_table('chat_members',
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('chat_id', 'user_id')
)
op.create_index('idx_chat_members_user', 'chat_members', ['user_id', 'chat_id'], unique=False)
op.create_table('messages',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('sender_id', sa.UUID(), nullable=False),
sa.Column('text', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_index('idx_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
op.create_table('sessions',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.Column('token_hash', sa.String(length=64), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_sessions_expires_at'), 'sessions', ['expires_at'], unique=False)
op.create_index(op.f('ix_sessions_token_hash'), 'sessions', ['token_hash'], unique=True)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_sessions_token_hash'), table_name='sessions')
op.drop_index(op.f('ix_sessions_expires_at'), table_name='sessions')
op.drop_table('sessions')
op.drop_index('idx_messages_chat_created_id', table_name='messages')
op.drop_table('messages')
op.drop_index('idx_chat_members_user', table_name='chat_members')
op.drop_table('chat_members')
op.drop_index(op.f('ix_users_username'), table_name='users')
op.drop_table('users')
op.drop_index('idx_chats_created_id', table_name='chats')
op.drop_table('chats')
# ### end Alembic commands ###
+12
View File
@@ -0,0 +1,12 @@
fastapi==0.110.0
uvicorn[standard]==0.29.0
pydantic==2.6.4
sqlalchemy[asyncio]==2.0.29
asyncpg==0.29.0
alembic==1.13.1
bcrypt==4.1.2
python-dotenv==1.0.1
redis==5.0.3
httpx==0.27.0
pytest==8.1.1
pytest-asyncio==0.23.5
+91
View File
@@ -0,0 +1,91 @@
#!/usr/bin/env python3
"""10 клиентов × 10 сообщений = 100 уникальных."""
import asyncio
import base64
import json
import urllib.request
import urllib.error
import uuid
from concurrent.futures import ThreadPoolExecutor
BASE = "http://127.0.0.1:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
def call(method, path, body=None, token=None):
h = {"Accept": "application/json"}
if token:
h["Authorization"] = f"Bearer {token}"
data = None
if body is not None:
data = json.dumps(body).encode("utf-8")
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=30) as r:
payload = r.read()
return r.status, (json.loads(payload) if payload else None)
except urllib.error.HTTPError as e:
payload = e.read()
return e.code, (json.loads(payload) if payload else None)
def create_user_and_login(name):
s, u = call("POST", "/api/v1/users",
{"username": name, "display_name": name, "password": PASSWORD})
assert s == 201, f"create_user {name}: {s} {u}"
cred = base64.b64encode(f"{name}:{PASSWORD}".encode()).decode()
req = urllib.request.Request(
BASE + "/api/v1/auth/sessions",
headers={"Authorization": f"Basic {cred}"},
method="POST",
)
with urllib.request.urlopen(req, timeout=30) as r:
session = json.loads(r.read())
return u, session["token"]
def main():
users = [create_user_and_login(f"conc_{i}_{uuid.uuid4().hex[:6]}") for i in range(10)]
owner, owner_token = users[0]
chat = call("POST", "/api/v1/chats",
{"title": "concurrent", "member_ids": [u["id"] for u, _ in users]},
token=owner_token)[1]
cid = chat["id"]
def post_10(user_and_token):
_, token = user_and_token
results = []
for k in range(10):
s, m = call("POST", f"/api/v1/chats/{cid}/messages",
{"text": f"m{k}"}, token=token)
results.append((s, m))
return results
with ThreadPoolExecutor(max_workers=10) as ex:
results = []
for fut in [ex.submit(post_10, u) for u in users]:
results.extend(fut.result())
failures = [r for r in results if r[0] != 201]
assert not failures, f"{len(failures)} failed posts"
seen, cursor = set(), None
while True:
path = f"/api/v1/chats/{cid}/messages?limit=100"
if cursor:
path += f"&cursor={cursor}"
s, page = call("GET", path, token=owner_token)
for m in page["items"]:
seen.add(m["id"])
cursor = page["next_cursor"]
if not cursor:
break
print(f"unique messages: {len(seen)} / 100")
assert len(seen) == 100, f"expected 100, got {len(seen)}"
print("PASS: no lost or duplicated messages")
if __name__ == "__main__":
main()
+86
View File
@@ -0,0 +1,86 @@
import asyncio
import base64
import json
import urllib.error
import urllib.request
import uuid
import pytest
BASE = "http://127.0.0.1:8080"
PASSWORD = "Example-only-not-a-real-secret-123"
def _post(path, body, token=None):
h = {"Content-Type": "application/json", "Accept": "application/json"}
if token:
h["Authorization"] = f"Bearer {token}"
data = json.dumps(body).encode("utf-8")
req = urllib.request.Request(BASE + path, data=data, method="POST", headers=h)
try:
with urllib.request.urlopen(req, timeout=10) as r:
return r.status, json.loads(r.read())
except urllib.error.HTTPError as e:
payload = e.read()
try:
return e.code, json.loads(payload) if payload else None
except ValueError:
return e.code, None
def _post_basic(path, username, password):
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
req = urllib.request.Request(
BASE + path, method="POST",
headers={"Authorization": f"Basic {cred}", "Accept": "application/json"},
)
with urllib.request.urlopen(req, timeout=10) as r:
return r.status, json.loads(r.read())
def _create_user(name):
return _post("/api/v1/users", {
"username": name, "display_name": name, "password": PASSWORD,
})
def _login(name):
_, body = _post_basic("/api/v1/auth/sessions", name, PASSWORD)
return body["token"]
def test_duplicate_username_race():
name = f"dup_{uuid.uuid4().hex[:8]}"
import threading
results = [None, None]
def worker(i):
results[i] = _create_user(name)
t1 = threading.Thread(target=worker, args=(0,))
t2 = threading.Thread(target=worker, args=(1,))
t1.start(); t2.start()
t1.join(); t2.join()
codes = sorted([results[0][0], results[1][0]])
assert codes == [201, 409], codes
def test_chat_with_unknown_member_rolls_back():
name = f"cb_{uuid.uuid4().hex[:8]}"
s, me = _create_user(name)
assert s == 201, me
tok = _login(name)
s, _ = _post("/api/v1/chats", {
"title": "x", "member_ids": [me["id"], str(uuid.uuid4())],
}, token=tok)
assert s == 404
def test_message_to_missing_chat():
name = f"mc_{uuid.uuid4().hex[:8]}"
_create_user(name)
tok = _login(name)
s, _ = _post(f"/api/v1/chats/{uuid.uuid4()}/messages", {"text": "hi"}, token=tok)
assert s == 404