chore: migrate lab 2 implementation

This commit is contained in:
2026-10-23 16:17:29 +03:00
parent 0ab3a341aa
commit 3f7c306f4f
50 changed files with 1642 additions and 9 deletions
+6 -7
View File
@@ -4,10 +4,9 @@ APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
POSTGRES_USER=messenger
POSTGRES_PASSWORD=change-me-local
POSTGRES_DB=messenger
DATABASE_URL=postgresql+asyncpg://messenger:change-me-local@postgres:5432/messenger
REDIS_URL=redis://redis:6379/0
+17
View File
@@ -0,0 +1,17 @@
FROM python:3.13.15-slim
WORKDIR /app
COPY requirements.txt .
RUN python -m pip install -r requirements.txt \
&& useradd --uid 10001 --user-group --no-create-home --shell /usr/sbin/nologin app
COPY app ./app
COPY alembic ./alembic
COPY alembic.ini .
USER 10001:10001
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD ["python", "-c", "import urllib.request;urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=3).read()"]
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "5"]
+14
View File
@@ -0,0 +1,14 @@
FROM python:3.13.15-slim
WORKDIR /tests
COPY requirements-dev.txt .
RUN python -m pip install --no-cache-dir -r requirements-dev.txt \
&& useradd --uid 10001 --user-group --no-create-home --shell /usr/sbin/nologin tests
COPY lab.json .
COPY contracts ./contracts
COPY tests ./tests
RUN chown -R tests:tests /tests
USER 10001:10001
CMD ["pytest", "-q"]
+36
View File
@@ -0,0 +1,36 @@
[alembic]
script_location = alembic
prepend_sys_path = .
sqlalchemy.url = placeholder://configured-at-runtime
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
[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
+53
View File
@@ -0,0 +1,53 @@
from __future__ import annotations
import asyncio
from logging.config import fileConfig
from alembic import context
from sqlalchemy import pool
from sqlalchemy.ext.asyncio import async_engine_from_config
from app.config import load_settings
from app.db.postgres import Base
from app import models # noqa: F401 - imports ORM models into Base.metadata
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
def _url() -> str:
return load_settings().database_url
def run_migrations_offline() -> None:
context.configure(url=_url(), target_metadata=target_metadata, literal_binds=True, dialect_opts={'paramstyle': 'named'})
with context.begin_transaction():
context.run_migrations()
def _run_migrations(connection) -> None:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
async def _run_migrations_async() -> None:
configuration = config.get_section(config.config_ini_section, {})
configuration['sqlalchemy.url'] = _url()
connectable = async_engine_from_config(configuration, prefix='sqlalchemy.', poolclass=pool.NullPool)
async with connectable.connect() as connection:
await connection.run_sync(_run_migrations)
await connectable.dispose()
def run_migrations_online() -> None:
asyncio.run(_run_migrations_async())
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+22
View File
@@ -0,0 +1,22 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,64 @@
"""Initial PostgreSQL schema for lab 2.
Revision ID: 20261019_0001
Revises:
Create Date: 2026-10-19
"""
from alembic import op
import sqlalchemy as sa
revision = '20261019_0001'
down_revision = None
branch_labels = None
depends_on = None
def upgrade() -> None:
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'),
sa.UniqueConstraint('username'),
)
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_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('chat_members_user_chat_idx', 'chat_members', ['user_id', 'chat_id'])
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.String(length=4000), 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('messages_history_idx', 'messages', ['chat_id', 'created_at', 'id'])
def downgrade() -> None:
op.drop_index('messages_history_idx', table_name='messages')
op.drop_table('messages')
op.drop_index('chat_members_user_chat_idx', table_name='chat_members')
op.drop_table('chat_members')
op.drop_table('chats')
op.drop_table('users')
+1
View File
@@ -0,0 +1 @@
"""Мессенджер на PostgreSQL и Redis, лабораторная 2."""
+1
View File
@@ -0,0 +1 @@
"""HTTP-граница: FastAPI, коды состояния, формат ошибок, курсоры."""
+28
View File
@@ -0,0 +1,28 @@
import base64
import json
from uuid import UUID
from ..domain.errors import Invalid
from ..domain.models import Keyset
from .timefmt import from_rfc3339, to_rfc3339
MAX_LENGTH = 512
def encode(scope: str, position: Keyset) -> str:
payload = {'s': scope, 't': to_rfc3339(position.created_at), 'i': str(position.id)}
raw = json.dumps(payload, separators=(',', ':'), sort_keys=True).encode('utf-8')
return base64.urlsafe_b64encode(raw).decode('ascii').rstrip('=')
def decode(scope: str, value: str) -> Keyset:
if not value or len(value) > MAX_LENGTH:
raise Invalid('cursor недействителен для этого запроса')
try:
raw = base64.urlsafe_b64decode(value + '=' * (-len(value) % 4))
payload = json.loads(raw)
if not isinstance(payload, dict) or payload.get('s') != scope:
raise ValueError('scope mismatch')
return Keyset(created_at=from_rfc3339(payload['t']), id=UUID(payload['i']))
except Exception:
raise Invalid('cursor недействителен для этого запроса') from None
+72
View File
@@ -0,0 +1,72 @@
from __future__ import annotations
from dataclasses import dataclass
from fastapi import Depends, Header, HTTPException, Request, status
from ..db.redis import RedisSessionStore
from ..domain.errors import Unauthorized
from ..domain.models import User
from ..services.chats import ChatService
from ..services.messages import MessageService
from ..services.users import UserService
_BEARER_CHALLENGE = 'Bearer realm="messenger"'
@dataclass(frozen=True, slots=True)
class Services:
users: UserService
chats: ChatService
messages: MessageService
sessions: RedisSessionStore
def services(request: Request) -> Services:
return request.app.state.services
def user_service(container: Services = Depends(services)) -> UserService:
return container.users
def chat_service(container: Services = Depends(services)) -> ChatService:
return container.chats
def message_service(container: Services = Depends(services)) -> MessageService:
return container.messages
def session_store(container: Services = Depends(services)) -> RedisSessionStore:
return container.sessions
def _bearer_error() -> HTTPException:
return HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='требуется действующая Bearer-сессия',
headers={'WWW-Authenticate': _BEARER_CHALLENGE},
)
async def bearer_token(authorization: str | None = Header(None)) -> str:
if not authorization:
raise _bearer_error()
scheme, separator, token = authorization.partition(' ')
if scheme.lower() != 'bearer' or not separator or not token or token.strip() != token:
raise _bearer_error()
return token
async def current_user(
token: str = Depends(bearer_token),
container: Services = Depends(services),
) -> User:
user_id = await container.sessions.get_user_id(token)
if user_id is None:
raise _bearer_error()
try:
return await container.users.identify(user_id)
except Unauthorized:
raise _bearer_error() from None
+96
View File
@@ -0,0 +1,96 @@
import logging
from fastapi import FastAPI
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from sqlalchemy.exc import SQLAlchemyError
from starlette.exceptions import HTTPException as StarletteHTTPException
from ..domain.errors import Conflict, DomainError, Invalid, NotFound, Unauthorized, Unavailable
logger = logging.getLogger('app.error')
CODE_BY_STATUS = {
400: 'invalid_request',
401: 'unauthorized',
404: 'not_found',
409: 'conflict',
413: 'payload_too_large',
415: 'unsupported_media_type',
429: 'rate_limited',
500: 'internal_error',
503: 'unavailable',
}
STATUS_BY_DOMAIN = {
Invalid: 400,
Unauthorized: 401,
NotFound: 404,
Conflict: 409,
Unavailable: 503,
}
def code_for(status: int) -> str:
if status in CODE_BY_STATUS:
return CODE_BY_STATUS[status]
return 'invalid_request' if status < 500 else 'internal_error'
def error_response(status: int, message: str, request_id: str, code: str = '') -> JSONResponse:
return JSONResponse(
status_code=status,
content={'error': {'code': code or code_for(status), 'message': message, 'request_id': request_id}},
)
def _domain_status(error: DomainError) -> int:
for kind, status in STATUS_BY_DOMAIN.items():
if isinstance(error, kind):
return status
return 500
def _describe(error: RequestValidationError) -> str:
"""Краткое указание на пол, без stack trace и внутреннего устройства"""
for item in error.errors():
if item.get('type') == 'json_invalid':
return 'тело запроса не является корректным JSON'
location = '.'.join(str(part) for part in item.get('loc', ()) if part != 'body')
return f'некорректное поле {location}' if location else 'некорректный запрос'
return 'некорректный запрос'
def request_id(request) -> str:
return getattr(request.state, 'request_id', 'unknown')
def install(app: FastAPI) -> None:
@app.exception_handler(DomainError)
async def _on_domain(request, error: DomainError) -> JSONResponse:
return error_response(_domain_status(error), error.message, request_id(request))
@app.exception_handler(RequestValidationError)
async def _on_validation(request, error: RequestValidationError) -> JSONResponse:
return error_response(400, _describe(error), request_id(request))
@app.exception_handler(SQLAlchemyError)
async def _on_database(request, error: SQLAlchemyError) -> JSONResponse:
logger.warning('database error request_id=%s type=%s', request_id(request), type(error).__name__)
return error_response(503, 'база данных недоступна', request_id(request))
@app.exception_handler(OSError)
async def _on_storage_socket(request, error: OSError) -> JSONResponse:
logger.warning('storage socket error request_id=%s type=%s', request_id(request), type(error).__name__)
return error_response(503, 'обязательное хранилище недоступно', request_id(request))
@app.exception_handler(StarletteHTTPException)
async def _on_http(request, error: StarletteHTTPException) -> JSONResponse:
message = error.detail if isinstance(error.detail, str) and error.detail else 'ошибка запроса'
response = error_response(error.status_code, message, request_id(request))
for name, value in (error.headers or {}).items():
response.headers[name] = value
return response
__all__ = ['code_for', 'error_response', 'install']
+38
View File
@@ -0,0 +1,38 @@
import logging
from uuid import uuid4
from starlette.datastructures import MutableHeaders
from .errors import error_response
logger = logging.getLogger('app')
class RequestContext:
def __init__(self, app) -> None:
self.app = app
async def __call__(self, scope, receive, send) -> None:
if scope['type'] != 'http':
await self.app(scope, receive, send)
return
request_id = uuid4().hex
scope.setdefault('state', {})['request_id'] = request_id
started = False
async def send_wrapper(message) -> None:
nonlocal started
if message['type'] == 'http.response.start':
started = True
MutableHeaders(scope=message)['X-Request-Id'] = request_id
await send(message)
try:
await self.app(scope, receive, send_wrapper)
except Exception:
logger.exception(f'unhandled error request_id={request_id} path={scope.get("path")}')
if started:
raise
response = error_response(500, 'внутренняя ошибка', request_id)
await response(scope, receive, send_wrapper)
+3
View File
@@ -0,0 +1,3 @@
from . import auth, chats, health, messages, users
__all__ = ['auth', 'chats', 'health', 'messages', 'users']
+71
View File
@@ -0,0 +1,71 @@
from __future__ import annotations
import base64
from binascii import Error as Base64Error
from fastapi import APIRouter, Depends, Header, HTTPException, status
from ...auth.tokens import create_token
from ...db.redis import RedisSessionStore
from ...domain.models import User
from ...services.users import UserService
from ..deps import bearer_token, current_user, session_store, user_service
from ..schemas import SessionOut, UserOut
from ..timefmt import to_rfc3339
router = APIRouter(prefix='/api/v1/auth/sessions', tags=['auth'])
_BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
def _unauthorized_basic() -> HTTPException:
return HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='неверные учётные данные',
headers={'WWW-Authenticate': _BASIC_CHALLENGE},
)
def _parse_basic(authorization: str | None) -> tuple[str, str]:
if not authorization:
raise _unauthorized_basic()
scheme, separator, encoded = authorization.partition(' ')
if scheme.lower() != 'basic' or not separator or not encoded:
raise _unauthorized_basic()
try:
decoded = base64.b64decode(encoded, validate=True).decode('utf-8')
except (Base64Error, UnicodeDecodeError):
raise _unauthorized_basic() from None
username, separator, password = decoded.partition(':')
if not separator or not username:
raise _unauthorized_basic()
return username, password
@router.post('', status_code=status.HTTP_201_CREATED, response_model=SessionOut)
async def create_session(
authorization: str | None = Header(None),
users: UserService = Depends(user_service),
sessions: RedisSessionStore = Depends(session_store),
) -> SessionOut:
username, password = _parse_basic(authorization)
user = await users.authenticate(username, password)
if user is None:
raise _unauthorized_basic()
token = create_token()
expires_at = await sessions.create(user.id, token)
return SessionOut(
token=token,
token_type='Bearer',
expires_at=to_rfc3339(expires_at),
user=UserOut.from_domain(user),
)
@router.delete('/current', status_code=status.HTTP_204_NO_CONTENT, response_model=None)
async def revoke_session(
token: str = Depends(bearer_token),
_: User = Depends(current_user),
sessions: RedisSessionStore = Depends(session_store),
) -> None:
await sessions.revoke(token)
+49
View File
@@ -0,0 +1,49 @@
from typing import Optional
from uuid import UUID
from fastapi import APIRouter, Depends, Query
from ...domain.models import User
from ...services.chats import ChatService
from .. import cursors
from ..deps import chat_service, current_user
from ..schemas import (
LIMIT_DEFAULT,
LIMIT_MAX,
LIMIT_MIN,
ChatOut,
ChatPageOut,
CreateChat,
)
router = APIRouter(prefix='/api/v1/chats', tags=['chats'])
@router.post('', status_code=201, response_model=ChatOut)
async def create(
body: CreateChat,
actor: User = Depends(current_user),
chats: ChatService = Depends(chat_service),
) -> ChatOut:
return ChatOut.from_domain(await chats.create(actor, body.title, body.member_ids))
@router.get('', response_model=ChatPageOut)
async def page(
actor: User = Depends(current_user),
chats: ChatService = Depends(chat_service),
limit: int = Query(LIMIT_DEFAULT, ge=LIMIT_MIN, le=LIMIT_MAX),
cursor: Optional[str] = Query(None, min_length=1, max_length=cursors.MAX_LENGTH),
) -> ChatPageOut:
scope = f'chats:{actor.id}'
after = cursors.decode(scope, cursor) if cursor is not None else None
return ChatPageOut.from_domain(await chats.page(actor, after, limit), scope)
@router.get('/{chat_id}', response_model=ChatOut)
async def get(
chat_id: UUID,
actor: User = Depends(current_user),
chats: ChatService = Depends(chat_service),
) -> ChatOut:
return ChatOut.from_domain(await chats.get(actor, chat_id))
+28
View File
@@ -0,0 +1,28 @@
from fastapi import APIRouter, HTTPException, Request
from redis.exceptions import RedisError
from sqlalchemy import text
from sqlalchemy.exc import SQLAlchemyError
from ...domain.errors import Unavailable
from ..schemas import HealthOut
router = APIRouter(tags=['health'])
@router.get('/health/live', response_model=HealthOut)
async def live() -> HealthOut:
return HealthOut(status='ok')
@router.get('/health/ready', response_model=HealthOut)
async def ready(request: Request) -> HealthOut:
if not request.app.state.ready:
raise HTTPException(status_code=503, detail='приложение не готово принимать трафик')
try:
async with request.app.state.engine.connect() as connection:
await connection.execute(text('SELECT 1'))
await request.app.state.redis.ping()
except (SQLAlchemyError, RedisError, Unavailable, OSError):
raise HTTPException(status_code=503, detail='обязательное хранилище недоступно') from None
return HealthOut(status='ok')
+42
View File
@@ -0,0 +1,42 @@
from typing import Optional
from uuid import UUID
from fastapi import APIRouter, Depends, Query
from ...domain.models import User
from ...services.messages import MessageService
from .. import cursors
from ..deps import current_user, message_service
from ..schemas import (
LIMIT_DEFAULT,
LIMIT_MAX,
LIMIT_MIN,
CreateMessage,
MessageOut,
MessagePageOut,
)
router = APIRouter(prefix='/api/v1/chats/{chat_id}/messages', tags=['messages'])
@router.post('', status_code=201, response_model=MessageOut)
async def send(
chat_id: UUID,
body: CreateMessage,
actor: User = Depends(current_user),
messages: MessageService = Depends(message_service),
) -> MessageOut:
return MessageOut.from_domain(await messages.send(actor, chat_id, body.text))
@router.get('', response_model=MessagePageOut)
async def page(
chat_id: UUID,
actor: User = Depends(current_user),
messages: MessageService = Depends(message_service),
limit: int = Query(LIMIT_DEFAULT, ge=LIMIT_MIN, le=LIMIT_MAX),
cursor: Optional[str] = Query(None, min_length=1, max_length=cursors.MAX_LENGTH),
) -> MessagePageOut:
scope = f'messages:{chat_id}'
after = cursors.decode(scope, cursor) if cursor is not None else None
return MessagePageOut.from_domain(await messages.history(actor, chat_id, after, limit), scope)
+18
View File
@@ -0,0 +1,18 @@
from fastapi import APIRouter, Depends
from ...domain.models import User
from ...services.users import UserService
from ..deps import current_user, user_service
from ..schemas import CreateUser, UserOut
router = APIRouter(prefix='/api/v1', tags=['users'])
@router.post('/users', status_code=201, response_model=UserOut)
async def register(body: CreateUser, users: UserService = Depends(user_service)) -> UserOut:
return UserOut.from_domain(await users.register(body.username, body.display_name, body.password))
@router.get('/users/me', response_model=UserOut)
async def me(actor: User = Depends(current_user)) -> UserOut:
return UserOut.from_domain(actor)
+147
View File
@@ -0,0 +1,147 @@
from typing import Optional
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
from ..domain.models import Chat, Message, Page, User
from . import cursors
from .timefmt import to_rfc3339
NAME_MAX = 100
TEXT_MAX = 4000
MEMBERS_MAX = 100
LIMIT_MIN = 1
LIMIT_MAX = 100
LIMIT_DEFAULT = 50
def not_blank(value: str) -> str:
if not value.strip():
raise ValueError('строка не может состоять только из пробельных символов')
return value
class Strict(BaseModel):
model_config = ConfigDict(extra='forbid')
class HealthOut(Strict):
status: str = 'ok'
class CreateUser(Strict):
username: str = Field(min_length=3, max_length=32, pattern=r'^[a-z0-9_]{3,32}$')
display_name: str = Field(min_length=1, max_length=NAME_MAX)
password: str = Field(min_length=12, max_length=128)
@field_validator('display_name')
@classmethod
def _display_name(cls, value: str) -> str:
return not_blank(value)
class UserOut(Strict):
id: UUID
username: str
display_name: str
created_at: str
@classmethod
def from_domain(cls, user: User) -> 'UserOut':
return cls(
id=user.id,
username=user.username,
display_name=user.display_name,
created_at=to_rfc3339(user.created_at),
)
class SessionOut(Strict):
token: str = Field(min_length=32)
token_type: str = 'Bearer'
expires_at: str
user: UserOut
class CreateChat(Strict):
title: str = Field(min_length=1, max_length=NAME_MAX)
member_ids: list[UUID] = Field(min_length=1, max_length=MEMBERS_MAX)
@field_validator('title')
@classmethod
def _title(cls, value: str) -> str:
return not_blank(value)
@field_validator('member_ids')
@classmethod
def _members_unique(cls, value: list[UUID]) -> list[UUID]:
if len(set(value)) != len(value):
raise ValueError('member_ids не должен содержать дубликаты')
return value
class ChatOut(Strict):
id: UUID
title: str
member_ids: list[UUID]
created_at: str
@classmethod
def from_domain(cls, chat: Chat) -> 'ChatOut':
return cls(
id=chat.id,
title=chat.title,
member_ids=list(chat.member_ids),
created_at=to_rfc3339(chat.created_at),
)
class CreateMessage(Strict):
text: str = Field(min_length=1, max_length=TEXT_MAX)
@field_validator('text')
@classmethod
def _text(cls, value: str) -> str:
return not_blank(value)
class MessageOut(Strict):
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: str
@classmethod
def from_domain(cls, message: Message) -> 'MessageOut':
return cls(
id=message.id,
chat_id=message.chat_id,
sender_id=message.sender_id,
text=message.text,
created_at=to_rfc3339(message.created_at),
)
class ChatPageOut(Strict):
items: list[ChatOut]
next_cursor: Optional[str]
@classmethod
def from_domain(cls, page: Page, scope: str) -> 'ChatPageOut':
return cls(
items=[ChatOut.from_domain(chat) for chat in page.items],
next_cursor=cursors.encode(scope, page.next) if page.next else None,
)
class MessagePageOut(Strict):
items: list[MessageOut]
next_cursor: Optional[str]
@classmethod
def from_domain(cls, page: Page, scope: str) -> 'MessagePageOut':
return cls(
items=[MessageOut.from_domain(message) for message in page.items],
next_cursor=cursors.encode(scope, page.next) if page.next else None,
)
+11
View File
@@ -0,0 +1,11 @@
from datetime import datetime, timezone
def to_rfc3339(value: datetime) -> str:
return value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
def from_rfc3339(value: str) -> datetime:
if not isinstance(value, str) or not value.endswith('Z'):
raise ValueError('timestamp must end with Z')
return datetime.fromisoformat(value[:-1]).replace(tzinfo=timezone.utc)
+4
View File
@@ -0,0 +1,4 @@
from .passwords import hash_password, password_matches
from .tokens import create_token
__all__ = ['create_token', 'hash_password', 'password_matches']
+15
View File
@@ -0,0 +1,15 @@
from argon2 import PasswordHasher
from argon2.exceptions import VerificationError, VerifyMismatchError
_hasher = PasswordHasher()
def hash_password(password: str) -> str:
return _hasher.hash(password)
def password_matches(stored_hash: str, password: str) -> bool:
try:
return _hasher.verify(stored_hash, password)
except (VerifyMismatchError, VerificationError):
return False
+11
View File
@@ -0,0 +1,11 @@
import hashlib
import secrets
def create_token() -> str:
return secrets.token_urlsafe(32)
def session_key(token: str) -> str:
digest = hashlib.sha256(token.encode('utf-8')).hexdigest()
return f'session:{digest}'
+3
View File
@@ -0,0 +1,3 @@
from .settings import Settings, load_settings
__all__ = ['Settings', 'load_settings']
+36
View File
@@ -0,0 +1,36 @@
from __future__ import annotations
import os
from dataclasses import dataclass
from pathlib import Path
def _read_value(name: str, file_name: str) -> str:
value = os.getenv(name)
if value:
return value
path = os.getenv(file_name)
if path:
return Path(path).read_text(encoding='utf-8').strip()
raise RuntimeError(f'не задана настройка {name} или {file_name}')
@dataclass(frozen=True, slots=True)
class Settings:
database_url: str
redis_url: str
session_ttl_seconds: int
def load_settings() -> Settings:
try:
ttl = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
except ValueError as exc:
raise RuntimeError('SESSION_TTL_SECONDS должен быть целым числом') from exc
if ttl <= 0:
raise RuntimeError('SESSION_TTL_SECONDS должен быть больше нуля')
return Settings(
database_url=_read_value('DATABASE_URL', 'DATABASE_URL_FILE'),
redis_url=_read_value('REDIS_URL', 'CACHE_URL_FILE'),
session_ttl_seconds=ttl,
)
+4
View File
@@ -0,0 +1,4 @@
from .postgres import Base, create_engine, create_session_factory
from .redis import RedisSessionStore, create_redis
__all__ = ['Base', 'RedisSessionStore', 'create_engine', 'create_redis', 'create_session_factory']
+23
View File
@@ -0,0 +1,23 @@
from __future__ import annotations
from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
def create_engine(url: str) -> AsyncEngine:
return create_async_engine(
url,
pool_size=5,
max_overflow=5,
pool_timeout=5,
pool_pre_ping=True,
connect_args={'server_settings': {'statement_timeout': '5000'}},
)
def create_session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
return async_sessionmaker(engine, expire_on_commit=False)
+51
View File
@@ -0,0 +1,51 @@
from __future__ import annotations
from datetime import datetime, timedelta, timezone
from uuid import UUID
from redis.asyncio import Redis
from redis.exceptions import RedisError
from ..auth.tokens import session_key
from ..domain.errors import Unavailable
def create_redis(url: str) -> Redis:
return Redis.from_url(url, decode_responses=True, socket_connect_timeout=3, socket_timeout=3)
class RedisSessionStore:
def __init__(self, client: Redis, ttl_seconds: int) -> None:
self._client = client
self._ttl_seconds = ttl_seconds
async def create(self, user_id: UUID, token: str) -> datetime:
try:
await self._client.set(session_key(token), str(user_id), ex=self._ttl_seconds)
except RedisError as exc:
raise Unavailable('хранилище сессий недоступно') from exc
return datetime.now(timezone.utc) + timedelta(seconds=self._ttl_seconds)
async def get_user_id(self, token: str) -> UUID | None:
try:
value = await self._client.get(session_key(token))
except RedisError as exc:
raise Unavailable('хранилище сессий недоступно') from exc
if value is None:
return None
try:
return UUID(value)
except ValueError:
return None
async def revoke(self, token: str) -> None:
try:
await self._client.delete(session_key(token))
except RedisError as exc:
raise Unavailable('хранилище сессий недоступно') from exc
async def ping(self) -> None:
try:
await self._client.ping()
except RedisError as exc:
raise Unavailable('хранилище сессий недоступно') from exc
View File
+29
View File
@@ -0,0 +1,29 @@
from __future__ import annotations
class DomainError(Exception):
"""Сообщение попадает клиенту, поэтому не содержит внутренних деталей."""
def __init__(self, message: str) -> None:
super().__init__(message)
self.message = message
class Invalid(DomainError):
"""Запрос нарушает правила предметной области."""
class Unauthorized(DomainError):
"""Нет действительной идентификации."""
class NotFound(DomainError):
"""Объекта нет либо он недоступен вызывающему: снаружи это неразличимо."""
class Conflict(DomainError):
"""Состояние не позволяет выполнить операцию."""
class Unavailable(DomainError):
"""Обязательная внешняя зависимость временно недоступна."""
+56
View File
@@ -0,0 +1,56 @@
from dataclasses import dataclass
from datetime import datetime
from typing import Optional
from uuid import UUID
@dataclass(frozen=True, slots=True)
class User:
id: UUID
username: str
display_name: str
created_at: datetime
@dataclass(frozen=True, slots=True)
class Chat:
id: UUID
title: str
member_ids: tuple[UUID, ...]
created_at: datetime
def has_member(self, user_id: UUID) -> bool:
return user_id in self.member_ids
@dataclass(frozen=True, slots=True)
class Message:
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
@dataclass(frozen=True, slots=True)
class Keyset:
created_at: datetime
id: UUID
@property
def order(self) -> tuple[datetime, int]:
return (self.created_at, self.id.int)
@classmethod
def from_item(cls, item) -> 'Keyset':
return cls(created_at=item.created_at, id=item.id)
def order_key(item) -> tuple[datetime, int]:
return (item.created_at, item.id.int)
@dataclass(frozen=True, slots=True)
class Page:
items: tuple
next: Optional[Keyset]
+87
View File
@@ -0,0 +1,87 @@
"""Сборка FastAPI приложения и подключение обязательных хранилищ."""
from __future__ import annotations
import logging
import os
import sys
from contextlib import asynccontextmanager
from fastapi import FastAPI
from sqlalchemy import text
from .api import errors
from .api.deps import Services
from .api.middleware import RequestContext
from .api.routers import auth, chats, health, messages, users
from .config import load_settings
from .db import RedisSessionStore, create_engine, create_redis, create_session_factory
from .repositories import ChatRepository, MessageRepository, UserRepository
from .services.chats import ChatService
from .services.messages import MessageService
from .services.users import UserService
logger = logging.getLogger('app')
DESCRIPTION = 'PostgreSQL хранит данные мессенджера; Redis хранит активные сессии.'
def configure_logging() -> None:
logging.basicConfig(
level=os.getenv('LOG_LEVEL', 'info').upper(),
stream=sys.stdout,
format='%(asctime)s %(levelname)s %(name)s %(message)s',
force=True,
)
def create_app() -> FastAPI:
configure_logging()
@asynccontextmanager
async def lifespan(application: FastAPI):
application.state.ready = False
settings = load_settings()
engine = create_engine(settings.database_url)
redis = create_redis(settings.redis_url)
try:
async with engine.connect() as connection:
await connection.execute(text('SELECT 1'))
session_store = RedisSessionStore(redis, settings.session_ttl_seconds)
await session_store.ping()
session_factory = create_session_factory(engine)
user_repository = UserRepository(session_factory)
chat_repository = ChatRepository(session_factory)
message_repository = MessageRepository(session_factory)
application.state.services = Services(
users=UserService(user_repository),
chats=ChatService(chat_repository),
messages=MessageService(message_repository),
sessions=session_store,
)
application.state.engine = engine
application.state.redis = redis
application.state.ready = True
logger.info('startup storage=postgres redis_sessions=true')
yield
finally:
application.state.ready = False
await redis.aclose()
await engine.dispose()
logger.info('shutdown complete')
api = FastAPI(
title='MTUSI Messenger. LR 2',
version='1.2.0',
description=DESCRIPTION,
lifespan=lifespan,
)
api.router.redirect_slashes = False
api.state.ready = False
api.add_middleware(RequestContext)
errors.install(api)
for router in (health.router, users.router, auth.router, chats.router, messages.router):
api.include_router(router)
return api
app = create_app()
+5
View File
@@ -0,0 +1,5 @@
from .chat import ChatMemberRow, ChatRow
from .message import MessageRow
from .user import UserRow
__all__ = ['ChatMemberRow', 'ChatRow', 'MessageRow', 'UserRow']
+26
View File
@@ -0,0 +1,26 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import DateTime, ForeignKey, Index, String
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy.types import Uuid
from ..db.postgres import Base
class ChatRow(Base):
__tablename__ = 'chats'
id: Mapped[UUID] = mapped_column(Uuid, primary_key=True)
title: Mapped[str] = mapped_column(String(100), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
class ChatMemberRow(Base):
__tablename__ = 'chat_members'
__table_args__ = (Index('chat_members_user_chat_idx', 'user_id', 'chat_id'),)
chat_id: Mapped[UUID] = mapped_column(ForeignKey('chats.id', ondelete='CASCADE'), primary_key=True)
user_id: Mapped[UUID] = mapped_column(ForeignKey('users.id', ondelete='CASCADE'), primary_key=True)
+21
View File
@@ -0,0 +1,21 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import DateTime, ForeignKey, Index, String
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy.types import Uuid
from ..db.postgres import Base
class MessageRow(Base):
__tablename__ = 'messages'
__table_args__ = (Index('messages_history_idx', 'chat_id', 'created_at', 'id'),)
id: Mapped[UUID] = mapped_column(Uuid, primary_key=True)
chat_id: Mapped[UUID] = mapped_column(ForeignKey('chats.id', ondelete='CASCADE'), nullable=False)
sender_id: Mapped[UUID] = mapped_column(ForeignKey('users.id'), nullable=False)
text: Mapped[str] = mapped_column(String(4000), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+20
View File
@@ -0,0 +1,20 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import DateTime, String, Text
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy.types import Uuid
from ..db.postgres import Base
class UserRow(Base):
__tablename__ = 'users'
id: Mapped[UUID] = mapped_column(Uuid, primary_key=True)
username: Mapped[str] = mapped_column(String(32), unique=True, nullable=False)
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), nullable=False)
+5
View File
@@ -0,0 +1,5 @@
from .chats import ChatRepository
from .messages import MessageRepository
from .users import UserRepository
__all__ = ['ChatRepository', 'MessageRepository', 'UserRepository']
+69
View File
@@ -0,0 +1,69 @@
from __future__ import annotations
from datetime import datetime
from typing import Sequence
from uuid import UUID
from sqlalchemy import select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from ..domain.errors import Invalid
from ..domain.models import Chat, Keyset
from ..models.chat import ChatMemberRow, ChatRow
from ..models.user import UserRow
class ChatRepository:
def __init__(self, sessions: async_sessionmaker[AsyncSession]) -> None:
self._sessions = sessions
@staticmethod
def _to_domain(row: ChatRow, member_ids: Sequence[UUID]) -> Chat:
return Chat(id=row.id, title=row.title, member_ids=tuple(member_ids), created_at=row.created_at)
@staticmethod
async def _members(session: AsyncSession, chat_id: UUID) -> tuple[UUID, ...]:
result = await session.scalars(
select(ChatMemberRow.user_id)
.where(ChatMemberRow.chat_id == chat_id)
.order_by(ChatMemberRow.user_id)
)
return tuple(result)
async def create(self, chat_id: UUID, title: str, member_ids: Sequence[UUID], created_at: datetime) -> Chat:
async with self._sessions() as session:
async with session.begin():
found = set(await session.scalars(select(UserRow.id).where(UserRow.id.in_(member_ids))))
if len(found) != len(member_ids):
raise Invalid(f'member_ids содержит неизвестных участников: {len(member_ids) - len(found)}')
row = ChatRow(id=chat_id, title=title, created_at=created_at)
session.add(row)
await session.flush()
session.add_all(ChatMemberRow(chat_id=chat_id, user_id=user_id) for user_id in member_ids)
await session.flush()
return self._to_domain(row, member_ids)
async def get_for_member(self, chat_id: UUID, user_id: UUID) -> Chat | None:
async with self._sessions() as session:
row = await session.scalar(
select(ChatRow)
.join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id)
.where(ChatRow.id == chat_id, ChatMemberRow.user_id == user_id)
)
if row is None:
return None
return self._to_domain(row, await self._members(session, row.id))
async def page_for_member(self, user_id: UUID, after: Keyset | None, limit: int) -> list[Chat]:
async with self._sessions() as session:
query = (
select(ChatRow)
.join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id)
.where(ChatMemberRow.user_id == user_id)
.order_by(ChatRow.created_at, ChatRow.id)
.limit(limit)
)
if after is not None:
query = query.where(tuple_(ChatRow.created_at, ChatRow.id) > tuple_(after.created_at, after.id))
rows = list((await session.scalars(query)).all())
return [self._to_domain(row, await self._members(session, row.id)) for row in rows]
+70
View File
@@ -0,0 +1,70 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from ..domain.models import Keyset, Message
from ..models.chat import ChatMemberRow, ChatRow
from ..models.message import MessageRow
class MessageRepository:
def __init__(self, sessions: async_sessionmaker[AsyncSession]) -> None:
self._sessions = sessions
@staticmethod
def _to_domain(row: MessageRow) -> Message:
return Message(
id=row.id,
chat_id=row.chat_id,
sender_id=row.sender_id,
text=row.text,
created_at=row.created_at,
)
@staticmethod
async def _accessible_chat_id(session: AsyncSession, chat_id: UUID, user_id: UUID) -> UUID | None:
return await session.scalar(
select(ChatRow.id)
.join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id)
.where(ChatRow.id == chat_id, ChatMemberRow.user_id == user_id)
)
async def create_for_member(
self, message_id: UUID, chat_id: UUID, sender_id: UUID, text: str, created_at: datetime
) -> Message | None:
async with self._sessions() as session:
async with session.begin():
accessible_chat_id = await self._accessible_chat_id(session, chat_id, sender_id)
if accessible_chat_id is None:
return None
row = MessageRow(
id=message_id,
chat_id=accessible_chat_id,
sender_id=sender_id,
text=text,
created_at=created_at,
)
session.add(row)
await session.flush()
return self._to_domain(row)
async def page_for_member(
self, chat_id: UUID, user_id: UUID, after: Keyset | None, limit: int
) -> list[Message] | None:
async with self._sessions() as session:
accessible_chat_id = await self._accessible_chat_id(session, chat_id, user_id)
if accessible_chat_id is None:
return None
query = (
select(MessageRow)
.where(MessageRow.chat_id == accessible_chat_id)
.order_by(MessageRow.created_at, MessageRow.id)
.limit(limit)
)
if after is not None:
query = query.where(tuple_(MessageRow.created_at, MessageRow.id) > tuple_(after.created_at, after.id))
return [self._to_domain(row) for row in (await session.scalars(query)).all()]
+53
View File
@@ -0,0 +1,53 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from ..domain.errors import Conflict
from ..domain.models import User
from ..models.user import UserRow
class UserRepository:
def __init__(self, sessions: async_sessionmaker[AsyncSession]) -> None:
self._sessions = sessions
@staticmethod
def _to_domain(row: UserRow) -> User:
return User(id=row.id, username=row.username, display_name=row.display_name, created_at=row.created_at)
async def register(
self, user_id: UUID, username: str, display_name: str, password_hash: str, created_at: datetime
) -> User:
row = UserRow(
id=user_id,
username=username,
display_name=display_name,
password_hash=password_hash,
created_at=created_at,
)
try:
async with self._sessions() as session:
async with session.begin():
session.add(row)
await session.flush()
except IntegrityError as exc:
raise Conflict('username уже занят') from exc
return self._to_domain(row)
async def get_by_id(self, user_id: UUID) -> User | None:
async with self._sessions() as session:
row = await session.get(UserRow, user_id)
return self._to_domain(row) if row is not None else None
async def get_credentials(self, username: str) -> UserRow | None:
async with self._sessions() as session:
return await session.scalar(select(UserRow).where(UserRow.username == username))
@classmethod
def to_domain(cls, row: UserRow) -> User:
return cls._to_domain(row)
View File
+35
View File
@@ -0,0 +1,35 @@
from __future__ import annotations
from datetime import datetime, timezone
from typing import Optional, Sequence
from uuid import UUID, uuid4
from ..domain.errors import Invalid, NotFound
from ..domain.models import Chat, Keyset, Page, User
from ..repositories import ChatRepository
class ChatService:
def __init__(self, repository: ChatRepository) -> None:
self._repository = repository
async def create(self, actor: User, title: str, member_ids: Sequence[UUID]) -> Chat:
if actor.id not in member_ids:
raise Invalid('вызывающий должен входить в member_ids')
return await self._repository.create(
chat_id=uuid4(),
title=title,
member_ids=member_ids,
created_at=datetime.now(timezone.utc),
)
async def get(self, actor: User, chat_id: UUID) -> Chat:
chat = await self._repository.get_for_member(chat_id, actor.id)
if chat is None:
raise NotFound('чат не найден')
return chat
async def page(self, actor: User, after: Optional[Keyset], limit: int) -> Page:
rows = await self._repository.page_for_member(actor.id, after, limit + 1)
items = tuple(rows[:limit])
return Page(items=items, next=Keyset.from_item(items[-1]) if len(rows) > limit else None)
+35
View File
@@ -0,0 +1,35 @@
from __future__ import annotations
from datetime import datetime, timezone
from typing import Optional
from uuid import UUID, uuid4
from ..domain.errors import NotFound
from ..domain.models import Keyset, Message, Page, User
from ..repositories import MessageRepository
class MessageService:
def __init__(self, repository: MessageRepository) -> None:
self._repository = repository
async def send(self, actor: User, chat_id: UUID, text: str) -> Message:
message = await self._repository.create_for_member(
message_id=uuid4(),
chat_id=chat_id,
sender_id=actor.id,
text=text,
created_at=datetime.now(timezone.utc),
)
if message is None:
raise NotFound('чат не найден')
return message
async def history(
self, actor: User, chat_id: UUID, after: Optional[Keyset], limit: int
) -> Page:
rows = await self._repository.page_for_member(chat_id, actor.id, after, limit + 1)
if rows is None:
raise NotFound('чат не найден')
items = tuple(rows[:limit])
return Page(items=items, next=Keyset.from_item(items[-1]) if len(rows) > limit else None)
+35
View File
@@ -0,0 +1,35 @@
from __future__ import annotations
from datetime import datetime, timezone
from uuid import UUID, uuid4
from ..auth.passwords import hash_password, password_matches
from ..domain.errors import Unauthorized
from ..domain.models import User
from ..repositories import UserRepository
class UserService:
def __init__(self, repository: UserRepository) -> None:
self._repository = repository
async def register(self, username: str, display_name: str, password: str) -> User:
return await self._repository.register(
user_id=uuid4(),
username=username,
display_name=display_name,
password_hash=hash_password(password),
created_at=datetime.now(timezone.utc),
)
async def identify(self, user_id: UUID) -> User:
user = await self._repository.get_by_id(user_id)
if user is None:
raise Unauthorized('требуется действующая сессия')
return user
async def authenticate(self, username: str, password: str) -> User | None:
row = await self._repository.get_credentials(username)
if row is None or not password_matches(row.password_hash, password):
return None
return self._repository.to_domain(row)
+1 -2
View File
@@ -1,11 +1,10 @@
# Topology worksheet, deliberately NOT a runnable stack (no application supplied).
# Implement compose.yaml or stack.yaml; do not submit this empty file as deployment.
# Service names below are logical roles, not imposed container names.
x-lab-number: 3
x-lab-number: 2
x-required-roles:
- api
- postgres
- load_balancer
# TODO: implement real images/builds, network wiring, volumes, healthchecks,
# credentials and bootstrap. Details: contracts/infrastructure.json and README.md.
services: {}
+62
View File
@@ -0,0 +1,62 @@
services:
postgres:
image: postgres:17.4-alpine
environment:
POSTGRES_USER: messenger_test
POSTGRES_PASSWORD: messenger_test
POSTGRES_DB: messenger_test
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger_test -d messenger_test"]
interval: 2s
timeout: 2s
retries: 30
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 2s
timeout: 2s
retries: 30
migrate:
build: .
command: ["alembic", "upgrade", "head"]
environment:
DATABASE_URL: postgresql+asyncpg://messenger_test:messenger_test@postgres:5432/messenger_test
REDIS_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: 1
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
build: .
environment:
DATABASE_URL: postgresql+asyncpg://messenger_test:messenger_test@postgres:5432/messenger_test
REDIS_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: 1
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3).read()"]
interval: 2s
timeout: 2s
retries: 30
tests:
build:
context: .
dockerfile: Dockerfile.test
environment:
BASE_URL: http://api:8080
SESSION_TTL_SECONDS: 1
depends_on:
api:
condition: service_healthy
restart: "no"
+61
View File
@@ -0,0 +1,61 @@
services:
postgres:
image: postgres:17.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 20
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 20
migrate:
build: .
command: ["alembic", "upgrade", "head"]
environment:
DATABASE_URL: ${DATABASE_URL}
REDIS_URL: ${REDIS_URL}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS}
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
build: .
environment:
DATABASE_URL: ${DATABASE_URL}
REDIS_URL: ${REDIS_URL}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS}
LOG_LEVEL: ${LOG_LEVEL:-info}
ports:
- "${APP_PORT:-8080}:8080"
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3).read()"]
interval: 10s
timeout: 3s
retries: 10
volumes:
postgres_data:
redis_data:
+1
View File
@@ -1,2 +1,3 @@
# Only for full OpenAPI/JSON Schema validation; HTTP tests use stdlib.
openapi-spec-validator==0.7.2
pytest==8.3.5
+7
View File
@@ -0,0 +1,7 @@
fastapi==0.115.12
uvicorn[standard]==0.34.2
SQLAlchemy[asyncio]==2.0.40
asyncpg==0.30.0
alembic==1.15.2
redis==5.2.1
argon2-cffi==25.1.0