initial commit before level 3

This commit is contained in:
2026-11-09 17:28:50 +03:00
parent ec540a1a72
commit 304a3239db
26 changed files with 2066 additions and 3 deletions
+5 -3
View File
@@ -4,9 +4,11 @@ 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:
# compose.yaml gives api/migrate DB_HOST/DB_USER/DB_NAME and
# DB_PASSWORD_FILE=/run/secrets/postgres_password (secret from POSTGRES_PASSWORD).
POSTGRES_USER=messenger
POSTGRES_PASSWORD=change-me-locally
POSTGRES_DB=messenger
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
+40
View File
@@ -0,0 +1,40 @@
# Закреплённая среда выполнения. Тег называет версию, digest — то, что Docker реально скачает.
FROM python:3.14.8-slim-bookworm@sha256:c8137f4c460908c8763f281c8f22c431eb5c538514ba9553fc3a89c06b7cfb88
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1
# Значения по умолчанию, секретов нет. `docker run --env-file .env` перекрывает их при запуске.
ENV APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_ENV=lab \
LOG_LEVEL=info \
DRAIN_SECONDS=4 \
SHUTDOWN_TIMEOUT_SECONDS=3 \
SESSION_TTL_SECONDS=3600
RUN groupadd --gid 10001 app \
&& useradd --uid 10001 --gid app --create-home --shell /usr/sbin/nologin app
WORKDIR /app
COPY requirements.txt .
RUN python -m pip install --no-cache-dir --disable-pip-version-check --root-user-action=ignore -r requirements.txt
COPY --chown=app:app app ./app
COPY --chown=app:app migrations ./migrations
COPY --chown=app:app contracts/openapi.json ./contracts/openapi.json
USER app
# Visible as X-App-Version: shows which build served a request during a rolling update.
ARG APP_VERSION=dev
ENV APP_VERSION=${APP_VERSION}
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=15s --retries=3 \
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ['APP_PORT'], timeout=2)"]
STOPSIGNAL SIGTERM
CMD ["python", "-m", "app"]
View File
+49
View File
@@ -0,0 +1,49 @@
import logging
import threading
import uvicorn
from .config import load_settings
from .drain import draining
logger = logging.getLogger('messenger')
class DrainingServer(uvicorn.Server):
"""First SIGTERM/SIGINT: keep serving for drain_seconds with readiness 503, then uvicorn's graceful stop.
drain_seconds must exceed the LB detection time (HAProxy inter 1s x fall 2 + timeout check 1s),
so the replica is out of rotation before it stops accepting connections.
"""
def __init__(self, config: uvicorn.Config, drain_seconds: float):
super().__init__(config)
self.drain_seconds = drain_seconds
def handle_exit(self, sig, frame) -> None:
if draining.is_set() or self.drain_seconds <= 0:
draining.set()
super().handle_exit(sig, frame)
return
draining.set()
logger.warning('signal %s: draining for %.1f s before shutdown', sig, self.drain_seconds)
timer = threading.Timer(self.drain_seconds, super().handle_exit, (sig, frame))
timer.daemon = True
timer.start()
def main() -> None:
settings = load_settings()
config = uvicorn.Config(
'app.main:app',
host=settings.host,
port=settings.port,
log_level=settings.log_level,
timeout_graceful_shutdown=settings.shutdown_timeout,
timeout_keep_alive=settings.keepalive_timeout,
)
DrainingServer(config, settings.drain_seconds).run()
if __name__ == '__main__':
main()
+30
View File
@@ -0,0 +1,30 @@
"""Basic is only for creating a session. Every other route accepts only Bearer."""
import base64
import binascii
from typing import Optional, Tuple
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
def parse_basic(header: str) -> Optional[Tuple[str, str]]:
"""username:password. The password may itself contain a colon."""
scheme, separator, param = header.partition(' ')
if separator != ' ' or scheme.lower() != 'basic' or not param or param != param.strip():
return None
try:
decoded = base64.b64decode(param, validate=True)
text = decoded.decode('utf-8')
except (binascii.Error, UnicodeDecodeError, ValueError):
return None
username, separator, password = text.partition(':')
if separator != ':':
return None
return username, password
def parse_bearer(header: str) -> Optional[str]:
scheme, separator, token = header.partition(' ')
if separator != ' ' or scheme.lower() != 'bearer' or not token or token != token.strip() or ' ' in token:
return None
return token
+78
View File
@@ -0,0 +1,78 @@
import os
import socket
from dataclasses import dataclass
from pathlib import Path
from urllib.parse import quote
@dataclass(frozen=True)
class Settings:
host: str
port: int
env: str
log_level: str
shutdown_timeout: int
drain_seconds: float
keepalive_timeout: int
session_ttl_seconds: int
idempotency_ttl_seconds: int
database_url: str
instance_id: str
app_version: str
def _read_secret_file(file_var: str, file_name: str) -> str:
try:
value = Path(file_name).read_text(encoding='utf-8').strip()
except OSError:
raise RuntimeError('%s could not be read' % file_var) from None
if not value:
raise RuntimeError('%s is empty' % file_var)
return value
def _database_url() -> str:
"""DATABASE_URL_FILE, then DATABASE_URL, then DB_* parts with the password from DB_PASSWORD_FILE.
Secret values are never logged.
"""
file_name = os.getenv('DATABASE_URL_FILE', '').strip()
if file_name:
return _read_secret_file('DATABASE_URL_FILE', file_name)
value = os.getenv('DATABASE_URL', '').strip()
if value:
return value
password_file = os.getenv('DB_PASSWORD_FILE', '').strip()
if not password_file:
raise RuntimeError('DATABASE_URL, DATABASE_URL_FILE or DB_PASSWORD_FILE is required')
password = _read_secret_file('DB_PASSWORD_FILE', password_file)
parts = {name: os.getenv(name, '').strip() for name in ('DB_HOST', 'DB_USER', 'DB_NAME')}
missing = [name for name, part in parts.items() if not part]
if missing:
raise RuntimeError('%s required with DB_PASSWORD_FILE' % ', '.join(missing))
return 'postgresql://%s:%s@%s:%s/%s' % (
quote(parts['DB_USER'], safe=''),
quote(password, safe=''),
parts['DB_HOST'],
int(os.getenv('DB_PORT', '5432')),
quote(parts['DB_NAME'], safe=''),
)
def load_settings() -> Settings:
return Settings(
host=os.getenv('APP_HOST', '0.0.0.0'),
port=int(os.getenv('APP_PORT', '8080')),
env=os.getenv('APP_ENV', 'lab'),
log_level=os.getenv('LOG_LEVEL', 'info').lower(),
shutdown_timeout=int(os.getenv('SHUTDOWN_TIMEOUT_SECONDS', '3')),
drain_seconds=float(os.getenv('DRAIN_SECONDS', '4')),
# Longer than HAProxy's idle-connection purge (pool-purge-delay 5 s), so the LB usually closes them first.
keepalive_timeout=int(os.getenv('KEEPALIVE_TIMEOUT_SECONDS', '10')),
session_ttl_seconds=int(os.getenv('SESSION_TTL_SECONDS', '3600')),
idempotency_ttl_seconds=int(os.getenv('IDEMPOTENCY_TTL_SECONDS', '86400')),
database_url=_database_url(),
# Docker sets the hostname to the short container ID, which stop-one.sh maps back to a container.
instance_id=os.getenv('INSTANCE_ID', '').strip() or socket.gethostname(),
app_version=os.getenv('APP_VERSION', 'dev').strip() or 'dev',
)
+47
View File
@@ -0,0 +1,47 @@
"""Connection pool. The URL is never written to the log."""
import asyncio
import logging
import os
import asyncpg
logger = logging.getLogger('messenger')
_ATTEMPTS = 40
def _pool_size(name: str, default: int) -> int:
raw = os.getenv(name, '').strip()
return int(raw) if raw else default
async def open_pool(database_url: str) -> asyncpg.Pool:
delay = 0.5
last_type = 'error'
min_size = _pool_size('DB_POOL_MIN', 1)
max_size = max(min_size, _pool_size('DB_POOL_MAX', 10))
for attempt in range(1, _ATTEMPTS + 1):
pool = None
try:
pool = await asyncpg.create_pool(
database_url,
min_size=min_size,
max_size=max_size,
timeout=5,
# Uploads are capped at 10 MiB; give that write room past the old 5 s JSON timeout.
command_timeout=30,
server_settings={'statement_timeout': '30000'},
)
async with pool.acquire() as conn:
await conn.execute('SELECT 1')
return pool
except Exception as exc:
last_type = type(exc).__name__
if pool is not None:
await pool.close()
if attempt == _ATTEMPTS:
break
logger.warning('database is not ready (%s), retrying', last_type)
await asyncio.sleep(delay)
delay = min(delay * 1.5, 2)
raise RuntimeError('database did not become reachable (%s)' % last_type)
+4
View File
@@ -0,0 +1,4 @@
"""Set on SIGTERM: readiness turns 503 so the LB stops routing here while requests are still served."""
import threading
draining = threading.Event()
+37
View File
@@ -0,0 +1,37 @@
class ApiError(Exception):
"""Expected failure: the message never contains internal details."""
def __init__(self, status: int, code: str, message: str, challenge: str | None = None) -> None:
super().__init__(message)
self.status = status
self.code = code
self.message = message
self.challenge = challenge
def invalid_request(message: str) -> ApiError:
return ApiError(400, 'invalid_request', message)
def unauthorized(message: str, challenge: str) -> ApiError:
return ApiError(401, 'unauthorized', message, challenge)
def not_found(message: str) -> ApiError:
return ApiError(404, 'not_found', message)
def conflict(message: str) -> ApiError:
return ApiError(409, 'conflict', message)
def payload_too_large(message: str) -> ApiError:
return ApiError(413, 'payload_too_large', message)
def unsupported_media_type(message: str) -> ApiError:
return ApiError(415, 'unsupported_media_type', message)
def unavailable(message: str) -> ApiError:
return ApiError(503, 'unavailable', message)
+84
View File
@@ -0,0 +1,84 @@
"""PNG/JPEG checks that look at the header only.
Dimensions come from IHDR or a JPEG SOF marker. The compressed pixel data is never unpacked,
so a small file cannot expand into an unbounded bitmap before the pixel limit is applied.
"""
from typing import NoReturn
from .errors import payload_too_large, unsupported_media_type
MAX_UPLOAD_BYTES = 10_485_760
MAX_IMAGE_PIXELS = 40_000_000
_PNG = b'\x89PNG\r\n\x1a\n'
# SOF markers that carry width and height. DHT/DAC/JPG are skipped by the length field.
_JPEG_SOF = {0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF}
def _reject() -> NoReturn:
raise unsupported_media_type('Файл не является PNG или JPEG')
def _check_pixels(width: int, height: int) -> None:
if width <= 0 or height <= 0:
_reject()
if width > MAX_IMAGE_PIXELS or height > MAX_IMAGE_PIXELS or width * height > MAX_IMAGE_PIXELS:
raise payload_too_large('Изображение превышает 40 миллионов пикселей')
def _png_size(data: bytes) -> None:
if len(data) < 24 or not data.startswith(_PNG):
_reject()
if int.from_bytes(data[8:12], 'big') != 13 or data[12:16] != b'IHDR':
_reject()
width = int.from_bytes(data[16:20], 'big')
height = int.from_bytes(data[20:24], 'big')
_check_pixels(width, height)
def _jpeg_size(data: bytes) -> None:
if len(data) < 4 or data[0:2] != b'\xff\xd8':
_reject()
index = 2
while index < len(data):
if data[index] != 0xFF:
_reject()
index += 1
while index < len(data) and data[index] == 0xFF:
index += 1
if index >= len(data):
break
marker = data[index]
index += 1
if marker in (0x01, 0xD8, 0xD9) or 0xD0 <= marker <= 0xD7:
if marker == 0xD9:
break
continue
if index + 2 > len(data):
break
segment_length = int.from_bytes(data[index:index + 2], 'big')
if segment_length < 2 or index + segment_length > len(data):
_reject()
# Start of scan: entropy-coded bytes follow. Dimensions must already have been seen.
if marker == 0xDA:
break
if marker in _JPEG_SOF:
if segment_length < 7:
_reject()
height = int.from_bytes(data[index + 3:index + 5], 'big')
width = int.from_bytes(data[index + 5:index + 7], 'big')
_check_pixels(width, height)
return
index += segment_length
_reject()
def inspect_image(data: bytes) -> str:
"""Return image/png or image/jpeg after a header check. Raises 413 or 415."""
if data.startswith(_PNG):
_png_size(data)
return 'image/png'
if data.startswith(b'\xff\xd8'):
_jpeg_size(data)
return 'image/jpeg'
_reject()
+120
View File
@@ -0,0 +1,120 @@
import json
import logging
import re
import uuid
from contextlib import asynccontextmanager
from pathlib import Path
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from .config import load_settings
from .db import open_pool
from .errors import ApiError
from .routes import router
from .store import Store
logger = logging.getLogger('messenger')
_SAFE_REQUEST_ID = re.compile(r'^[A-Za-z0-9._:-]{1,128}$')
_CODES = {
400: 'invalid_request',
401: 'unauthorized',
404: 'not_found',
409: 'conflict',
413: 'payload_too_large',
415: 'unsupported_media_type',
429: 'rate_limited',
503: 'unavailable',
}
_MESSAGES = {
'invalid_request': 'Некорректный запрос',
'unauthorized': 'Требуется идентификация',
'not_found': 'Объект не найден',
'internal_error': 'Внутренняя ошибка',
}
_BEARER_CHALLENGE = 'Bearer realm="messenger"'
def _error(status: int, code: str, message: str, request_id: str, challenge: str | None = None) -> JSONResponse:
body = {'error': {'code': code, 'message': message, 'request_id': request_id}}
headers = {'X-Request-Id': request_id}
if challenge:
headers['WWW-Authenticate'] = challenge
return JSONResponse(body, status_code=status, headers=headers)
def _request_id(request: Request) -> str:
return getattr(request.state, 'request_id', None) or str(uuid.uuid4())
_OPENAPI_PATH = Path(__file__).resolve().parents[1] / 'contracts' / 'openapi.json'
@asynccontextmanager
async def lifespan(app: FastAPI):
"""Migrations are not applied here: the one-shot migrate service runs them before replicas start."""
settings = load_settings()
pool = await open_pool(settings.database_url)
try:
app.state.store = Store(pool, settings.session_ttl_seconds, settings.idempotency_ttl_seconds)
logger.info('instance %s started', settings.instance_id)
yield
finally:
await pool.close()
def create_app() -> FastAPI:
app = FastAPI(
title='MTUSI Messenger lab4',
version='1.4.0',
lifespan=lifespan,
)
settings = load_settings()
instance_id = settings.instance_id
app_version = settings.app_version
def openapi():
if app.openapi_schema is None:
app.openapi_schema = json.loads(_OPENAPI_PATH.read_text(encoding='utf-8'))
return app.openapi_schema
app.openapi = openapi
@app.middleware('http')
async def request_context(request: Request, call_next):
"""Gives every response, including unexpected failures, an X-Request-Id, X-Instance-Id and X-App-Version."""
incoming = request.headers.get('X-Request-Id')
request_id = incoming if incoming and _SAFE_REQUEST_ID.match(incoming) else str(uuid.uuid4())
request.state.request_id = request_id
try:
response = await call_next(request)
except Exception:
logger.exception('request %s failed: %s %s', request_id, request.method, request.url.path)
response = _error(500, 'internal_error', _MESSAGES['internal_error'], request_id)
response.headers['X-Request-Id'] = request_id
response.headers['X-Instance-Id'] = instance_id
response.headers['X-App-Version'] = app_version
return response
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError) -> JSONResponse:
return _error(exc.status, exc.code, exc.message, _request_id(request), exc.challenge)
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError) -> JSONResponse:
return _error(400, 'invalid_request', _MESSAGES['invalid_request'], _request_id(request))
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException) -> JSONResponse:
code = _CODES.get(exc.status_code, 'internal_error' if exc.status_code >= 500 else 'invalid_request')
challenge = _BEARER_CHALLENGE if exc.status_code == 401 else None
return _error(exc.status_code, code, _MESSAGES.get(code, _MESSAGES['invalid_request']), _request_id(request), challenge)
app.include_router(router)
return app
app = create_app()
+64
View File
@@ -0,0 +1,64 @@
"""Apply numbered SQL files once. Run as a separate one-shot step: python -m app.migrate."""
import asyncio
import logging
from pathlib import Path
import asyncpg
from .config import load_settings
from .db import open_pool
logger = logging.getLogger('messenger')
_MIGRATIONS = Path(__file__).resolve().parents[1] / 'migrations'
# Any constant shared by all runners; serializes concurrent migrators across processes.
_LOCK_ID = 4_2026_0004
_BOOTSTRAP = """
CREATE TABLE IF NOT EXISTS schema_migrations (
version TEXT PRIMARY KEY,
applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
)
"""
def expected_versions() -> list[str]:
return sorted(path.name for path in _MIGRATIONS.glob('*.sql'))
async def apply_migrations(pool: asyncpg.Pool) -> None:
async with pool.acquire() as conn:
await conn.execute('SET statement_timeout = 0')
await conn.execute('SELECT pg_advisory_lock($1)', _LOCK_ID)
try:
await conn.execute(_BOOTSTRAP)
rows = await conn.fetch('SELECT version FROM schema_migrations')
applied = {row['version'] for row in rows}
for version in expected_versions():
if version in applied:
logger.info('migration %s already applied', version)
continue
sql = (_MIGRATIONS / version).read_text(encoding='utf-8')
async with conn.transaction():
await conn.execute(sql)
await conn.execute(
'INSERT INTO schema_migrations (version) VALUES ($1)',
version,
)
logger.info('applied migration %s', version)
finally:
await conn.execute('SELECT pg_advisory_unlock($1)', _LOCK_ID)
async def _main() -> None:
settings = load_settings()
pool = await open_pool(settings.database_url)
try:
await apply_migrations(pool)
finally:
await pool.close()
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO, format='%(levelname)s %(message)s')
asyncio.run(_main())
+43
View File
@@ -0,0 +1,43 @@
import base64
import json
import re
from typing import Mapping, Optional, Tuple
from .errors import invalid_request
# Position of the last item returned to the client.
Key = Tuple[str, str]
DEFAULT_LIMIT = 50
MAX_LIMIT = 100
_LIMIT = re.compile(r'^\d{1,3}$')
def encode_cursor(scope: str, key: Key) -> str:
"""Scope binds the cursor to one resource, so a foreign cursor is detectable."""
payload = json.dumps({'s': scope, 't': key[0], 'i': key[1]}, separators=(',', ':'))
return base64.urlsafe_b64encode(payload.encode('utf-8')).decode('ascii').rstrip('=')
def decode_cursor(value: str, scope: str) -> Key:
try:
raw = base64.urlsafe_b64decode(value + '=' * (-len(value) % 4))
payload = json.loads(raw)
created_at, item_id = payload['t'], payload['i']
belongs = payload['s'] == scope
except (ValueError, TypeError, KeyError):
raise invalid_request('Некорректный cursor') from None
if not belongs or not isinstance(created_at, str) or not isinstance(item_id, str):
raise invalid_request('Cursor относится к другому запросу') from None
return created_at, item_id
def parse_page(params: Mapping[str, str], scope: str) -> Tuple[int, Optional[Key]]:
raw_limit = params.get('limit')
limit = DEFAULT_LIMIT
if raw_limit is not None:
if not _LIMIT.match(raw_limit) or not 1 <= int(raw_limit) <= MAX_LIMIT:
raise invalid_request('limit должен быть целым числом от 1 до %d' % MAX_LIMIT)
limit = int(raw_limit)
raw_cursor = params.get('cursor')
return limit, decode_cursor(raw_cursor, scope) if raw_cursor is not None else None
+27
View File
@@ -0,0 +1,27 @@
"""Argon2id password hashes. The hash never leaves this module in an API response."""
from argon2 import PasswordHasher
from argon2.exceptions import VerificationError
_hasher = PasswordHasher()
# Same cost as a real hash, so a missing user is not faster than a wrong password.
_DUMMY_HASH = _hasher.hash('not-a-user-password')
_DUMMY_PASSWORD = 'not-a-user-password'
def hash_password(password: str) -> str:
return _hasher.hash(password)
def verify_password(password_hash: str, password: str) -> bool:
try:
return _hasher.verify(password_hash, password)
except VerificationError:
return False
def password_matches(stored_hash: str | None, password: str) -> bool:
"""One Argon2 check either way. An out-of-range secret is never the stored password."""
if stored_hash is None or not 12 <= len(password) <= 128 or not password.strip():
verify_password(_DUMMY_HASH, _DUMMY_PASSWORD)
return False
return verify_password(stored_hash, password)
+300
View File
@@ -0,0 +1,300 @@
import hashlib
import json
import re
import uuid
from typing import Optional, Sequence, Type, TypeVar
from fastapi import APIRouter, Depends, Request
from fastapi.responses import JSONResponse
from pydantic import BaseModel, ValidationError
from starlette.responses import Response
from .auth import BASIC_CHALLENGE, BEARER_CHALLENGE, parse_basic, parse_bearer
from .drain import draining
from .errors import invalid_request, not_found, payload_too_large, unauthorized, unavailable, unsupported_media_type
from .images import MAX_UPLOAD_BYTES, inspect_image
from .pagination import encode_cursor, parse_page
from .schemas import CreateChat, CreateMessage, CreateUser
from .store import Chat, Store, User
router = APIRouter()
Body = TypeVar('Body', bound=BaseModel)
_IDEMPOTENCY_KEY = re.compile(r'[A-Za-z0-9._:-]{1,128}')
async def get_store(request: Request) -> Store:
return request.app.state.store
async def current_user(request: Request) -> User:
"""Bearer only. X-User-Id is ignored and does not identify anyone."""
token = parse_bearer(request.headers.get('Authorization', ''))
if token is None:
raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE)
user = await request.app.state.store.user_for_token(token)
if user is None:
raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE)
return user
async def read_body(request: Request, model: Type[Body]) -> Body:
try:
payload = json.loads(await request.body())
except (UnicodeDecodeError, ValueError):
raise invalid_request('Тело запроса не является корректным JSON') from None
if not isinstance(payload, dict):
raise invalid_request('Тело запроса должно быть JSON-объектом')
try:
return model.model_validate(payload)
except ValidationError:
raise invalid_request('Тело запроса не соответствует контракту') from None
def _request_hash(payload: BaseModel) -> str:
"""Key order in the client JSON does not matter: the validated body is re-serialized canonically.
CreateMessage always includes attachment_ids, so a missing field and [] are the same body.
"""
canonical = json.dumps(payload.model_dump(), sort_keys=True, separators=(',', ':'), ensure_ascii=False)
return hashlib.sha256(canonical.encode('utf-8')).hexdigest()
def _filename(value: Optional[str]) -> str:
if value is None or not value.strip() or len(value) > 255:
raise invalid_request('Некорректное filename')
if any(ord(char) < 32 or ord(char) == 127 or char in '/\\' for char in value):
raise invalid_request('Некорректное filename')
return value
def _declared_image_type(value: Optional[str]) -> str:
if not value:
raise unsupported_media_type('Требуется Content-Type image/png или image/jpeg')
media = value.split(';', 1)[0].strip().lower()
if media not in ('image/png', 'image/jpeg'):
raise unsupported_media_type('Требуется Content-Type image/png или image/jpeg')
return media
async def _read_upload(request: Request) -> bytes:
declared = request.headers.get('content-length')
if declared is not None:
try:
size = int(declared)
except ValueError:
raise invalid_request('Некорректный Content-Length') from None
if size > MAX_UPLOAD_BYTES:
raise payload_too_large('Файл больше 10 МиБ')
buf = bytearray()
async for chunk in request.stream():
if len(buf) + len(chunk) > MAX_UPLOAD_BYTES:
raise payload_too_large('Файл больше 10 МиБ')
buf.extend(chunk)
return bytes(buf)
async def _member_chat(store: Store, chat_id: str, actor: User) -> Chat:
try:
canonical = str(uuid.UUID(chat_id))
except ValueError:
raise invalid_request('Некорректный chat_id') from None
chat = await store.find_chat(canonical, actor.id)
if chat is None:
raise not_found('Чат не найден')
return chat
def _page(items: Sequence, has_more: bool, scope: str) -> dict:
cursor: Optional[str] = None
if has_more and items:
cursor = encode_cursor(scope, (items[-1].created_at, items[-1].id))
return {'items': [item.to_dict() for item in items], 'next_cursor': cursor}
@router.get('/health/live')
async def liveness() -> JSONResponse:
return JSONResponse({'status': 'ok'})
@router.get('/health/ready')
async def readiness(store: Store = Depends(get_store)) -> JSONResponse:
if draining.is_set():
raise unavailable('Реплика завершает работу')
await store.ready()
return JSONResponse({'status': 'ok'})
@router.post('/api/v1/users')
async def register_user(request: Request, store: Store = Depends(get_store)) -> JSONResponse:
payload = await read_body(request, CreateUser)
user = await store.create_user(payload.username, payload.display_name, payload.password)
return JSONResponse(user.to_dict(), status_code=201)
@router.post('/api/v1/auth/sessions')
async def create_session(request: Request, store: Store = Depends(get_store)) -> JSONResponse:
parsed = parse_basic(request.headers.get('Authorization', ''))
if parsed is None:
raise unauthorized('Неверные учётные данные', BASIC_CHALLENGE)
user = await store.authenticate(*parsed)
if user is None:
raise unauthorized('Неверные учётные данные', BASIC_CHALLENGE)
token, expires_at = await store.create_session(user.id)
body = {
'token': token,
'token_type': 'Bearer',
'expires_at': expires_at,
'user': user.to_dict(),
}
return JSONResponse(body, status_code=201)
@router.delete('/api/v1/auth/sessions/current')
async def revoke_session(request: Request, actor: User = Depends(current_user)) -> Response:
token = parse_bearer(request.headers.get('Authorization', ''))
if token is None or not await request.app.state.store.revoke_session(token):
raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE)
return Response(status_code=204)
@router.get('/api/v1/users/me')
async def show_current_user(actor: User = Depends(current_user)) -> JSONResponse:
return JSONResponse(actor.to_dict())
@router.post('/api/v1/chats')
async def create_chat(
request: Request,
actor: User = Depends(current_user),
store: Store = Depends(get_store),
) -> JSONResponse:
payload = await read_body(request, CreateChat)
if actor.id not in payload.member_ids:
raise invalid_request('Создатель чата должен быть указан в member_ids')
chat = await store.create_chat(payload.title, payload.member_ids)
return JSONResponse(chat.to_dict(), status_code=201)
@router.get('/api/v1/chats')
async def list_chats(
request: Request,
actor: User = Depends(current_user),
store: Store = Depends(get_store),
) -> JSONResponse:
scope = 'chats:' + actor.id
limit, after = parse_page(request.query_params, scope)
chats, has_more = await store.list_chats(actor.id, limit, after)
return JSONResponse(_page(chats, has_more, scope))
@router.get('/api/v1/chats/{chat_id}')
async def show_chat(
chat_id: str,
actor: User = Depends(current_user),
store: Store = Depends(get_store),
) -> JSONResponse:
return JSONResponse((await _member_chat(store, chat_id, actor)).to_dict())
@router.post('/api/v1/chats/{chat_id}/messages')
async def send_message(
chat_id: str,
request: Request,
actor: User = Depends(current_user),
store: Store = Depends(get_store),
) -> JSONResponse:
chat = await _member_chat(store, chat_id, actor)
payload = await read_body(request, CreateMessage)
key = request.headers.get('Idempotency-Key')
if key is None or not _IDEMPOTENCY_KEY.fullmatch(key):
raise invalid_request('Требуется корректный Idempotency-Key')
message = await store.add_message(
chat.id,
actor.id,
payload.text,
payload.attachment_ids,
path='/api/v1/chats/%s/messages' % chat.id,
key=key,
request_hash=_request_hash(payload),
)
return JSONResponse(message.to_dict(), status_code=201)
@router.post('/api/v1/chats/{chat_id}/attachments')
async def upload_attachment(
chat_id: str,
request: Request,
actor: User = Depends(current_user),
store: Store = Depends(get_store),
) -> JSONResponse:
chat = await _member_chat(store, chat_id, actor)
filename = _filename(request.query_params.get('filename'))
declared = _declared_image_type(request.headers.get('content-type'))
data = await _read_upload(request)
actual = inspect_image(data)
if actual != declared:
raise unsupported_media_type('Содержимое не соответствует Content-Type')
attachment = await store.create_attachment(
chat.id,
actor.id,
filename,
actual,
data,
hashlib.sha256(data).hexdigest(),
)
return JSONResponse(attachment.to_dict(), status_code=201)
def _variant(request: Request) -> str:
raw = request.query_params.get('variant')
variant = 'original' if raw is None else raw
if variant not in ('original', 'thumbnail', 'crop', 'optimized'):
raise invalid_request('Некорректный variant')
return variant
@router.get('/api/v1/attachments/{attachment_id}')
async def show_attachment(
attachment_id: str,
actor: User = Depends(current_user),
store: Store = Depends(get_store),
) -> JSONResponse:
attachment = await store.find_attachment(attachment_id, actor.id)
if attachment is None:
raise not_found('Вложение не найдено')
return JSONResponse(attachment.to_dict())
@router.get('/api/v1/attachments/{attachment_id}/content')
async def download_attachment(
attachment_id: str,
request: Request,
actor: User = Depends(current_user),
store: Store = Depends(get_store),
) -> Response:
variant = _variant(request)
if variant != 'original':
attachment = await store.find_attachment(attachment_id, actor.id)
if attachment is None:
raise not_found('Вложение не найдено')
raise not_found('Вариант не найден')
found = await store.read_original(attachment_id, actor.id)
if found is None:
raise not_found('Вложение не найдено')
content_type, body = found
return Response(content=body, media_type=content_type)
@router.get('/api/v1/chats/{chat_id}/messages')
async def list_messages(
chat_id: str,
request: Request,
actor: User = Depends(current_user),
store: Store = Depends(get_store),
) -> JSONResponse:
chat = await _member_chat(store, chat_id, actor)
scope = 'messages:' + chat.id
limit, after = parse_page(request.query_params, scope)
messages, has_more = await store.list_messages(chat.id, limit, after)
return JSONResponse(_page(messages, has_more, scope))
+73
View File
@@ -0,0 +1,73 @@
"""Request bodies. The contract forbids unknown fields, wrong types and blank strings."""
import uuid
from typing import List
from pydantic import AfterValidator, BaseModel, ConfigDict, Field, field_validator, model_validator
from typing_extensions import Annotated
def _not_blank(value: str) -> str:
if not value.strip():
raise ValueError('value must not be whitespace only')
return value
def _canonical_uuid(value: str) -> str:
parsed = uuid.UUID(value)
if str(parsed) != value.lower():
raise ValueError('value must be a canonical UUID')
return str(parsed)
Username = Annotated[str, Field(pattern=r'^[a-z0-9_]{3,32}$')]
DisplayName = Annotated[str, Field(min_length=1, max_length=100), AfterValidator(_not_blank)]
Title = Annotated[str, Field(min_length=1, max_length=100), AfterValidator(_not_blank)]
Password = Annotated[str, Field(min_length=12, max_length=128), AfterValidator(_not_blank)]
UserId = Annotated[str, AfterValidator(_canonical_uuid)]
class CreateUser(BaseModel):
model_config = ConfigDict(extra='forbid')
username: Username
display_name: DisplayName
password: Password
class CreateChat(BaseModel):
model_config = ConfigDict(extra='forbid')
title: Title
member_ids: Annotated[List[UserId], Field(min_length=1, max_length=100)]
@field_validator('member_ids')
@classmethod
def _unique(cls, value: List[str]) -> List[str]:
if len(set(value)) != len(value):
raise ValueError('member_ids must be unique')
return value
class CreateMessage(BaseModel):
"""text is required. attachment_ids defaults to [], so a lab3 body {"text": "..."} stays valid.
A blank text is accepted only together with at least one attachment.
"""
model_config = ConfigDict(extra='forbid')
text: Annotated[str, Field(max_length=4000)]
attachment_ids: Annotated[List[UserId], Field(default_factory=list, max_length=10)]
@field_validator('attachment_ids')
@classmethod
def _unique_attachments(cls, value: List[str]) -> List[str]:
if len(set(value)) != len(value):
raise ValueError('attachment_ids must be unique')
return value
@model_validator(mode='after')
def _has_content(self) -> 'CreateMessage':
if not self.text.strip() and not self.attachment_ids:
raise ValueError('text or attachment_ids is required')
return self
+653
View File
@@ -0,0 +1,653 @@
import hashlib
import json
import secrets
import threading
import uuid
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from typing import Dict, List, Optional, Sequence, Tuple
import asyncpg
from .errors import conflict, invalid_request, not_found, unavailable
from .migrate import expected_versions
from .pagination import Key
from .passwords import hash_password, password_matches
@dataclass(frozen=True)
class User:
id: str
username: str
display_name: str
created_at: str
def to_dict(self) -> dict:
return {
'id': self.id,
'username': self.username,
'display_name': self.display_name,
'created_at': self.created_at,
}
@dataclass(frozen=True)
class Chat:
id: str
title: str
member_ids: Tuple[str, ...]
created_at: str
def to_dict(self) -> dict:
return {
'id': self.id,
'title': self.title,
'member_ids': list(self.member_ids),
'created_at': self.created_at,
}
@dataclass(frozen=True)
class Message:
id: str
chat_id: str
sender_id: str
text: str
created_at: str
attachment_ids: Tuple[str, ...] = ()
def to_dict(self) -> dict:
return {
'id': self.id,
'chat_id': self.chat_id,
'sender_id': self.sender_id,
'text': self.text,
'created_at': self.created_at,
'attachment_ids': list(self.attachment_ids),
}
@dataclass(frozen=True)
class Attachment:
id: str
chat_id: str
owner_id: str
filename: str
content_type: str
size_bytes: int
sha256: str
created_at: str
updated_at: str
def to_dict(self) -> dict:
return {
'id': self.id,
'chat_id': self.chat_id,
'owner_id': self.owner_id,
'filename': self.filename,
'content_type': self.content_type,
'size_bytes': self.size_bytes,
'sha256': self.sha256,
'status': 'ready',
'variants': [],
'error_code': None,
'created_at': self.created_at,
'updated_at': self.updated_at,
}
def _token_key(token: str) -> str:
return hashlib.sha256(token.encode('utf-8')).hexdigest()
def _stamp(moment: datetime) -> str:
return moment.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
def _parse_stamp(value: str) -> datetime:
if value.endswith('Z'):
value = value[:-1] + '+00:00'
return datetime.fromisoformat(value)
def _user(row: asyncpg.Record) -> User:
return User(str(row['id']), row['username'], row['display_name'], _stamp(row['created_at']))
def _as_uuid(value: str, message: str) -> uuid.UUID:
try:
return uuid.UUID(value)
except ValueError:
raise invalid_request(message) from None
def _db_down(exc: BaseException) -> bool:
return isinstance(exc, (
asyncpg.PostgresConnectionError,
asyncpg.InterfaceError,
asyncpg.CannotConnectNowError,
OSError,
TimeoutError,
))
class Store:
"""PostgreSQL is the only state shared by replicas: users, chats, sessions, messages and attachment bytes."""
def __init__(self, pool: asyncpg.Pool, session_ttl_seconds: int = 3600, idempotency_ttl_seconds: int = 86400) -> None:
self._pool = pool
self._session_ttl = timedelta(seconds=session_ttl_seconds)
self._idempotency_ttl = timedelta(seconds=idempotency_ttl_seconds)
self._lock = threading.Lock()
self._last_moment: Optional[datetime] = None
self._migrations = expected_versions()
def _now(self) -> datetime:
"""Strictly increasing within one process; across replicas order relies on the shared host clock."""
with self._lock:
moment = datetime.now(timezone.utc)
if self._last_moment is not None and moment <= self._last_moment:
moment = self._last_moment + timedelta(microseconds=1)
self._last_moment = moment
return moment
async def ready(self) -> None:
"""Ready only when PostgreSQL answers and the separate migrator has applied this build's schema."""
try:
async with self._pool.acquire() as conn:
applied = await conn.fetchval(
'SELECT count(*) FROM schema_migrations WHERE version = ANY($1::text[])',
self._migrations,
)
except Exception:
raise unavailable('Хранилище недоступно') from None
if applied != len(self._migrations):
raise unavailable('Схема БД ещё не применена')
async def create_user(self, username: str, display_name: str, password: str) -> User:
password_hash = hash_password(password)
user_id = uuid.uuid4()
created = self._now()
try:
async with self._pool.acquire() as conn:
await conn.execute(
'''
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)
''',
user_id,
username,
display_name,
password_hash,
created,
)
except asyncpg.UniqueViolationError:
raise conflict('Username уже занят') from None
return User(str(user_id), username, display_name, _stamp(created))
async def authenticate(self, username: str, password: str) -> Optional[User]:
try:
async with self._pool.acquire() as conn:
row = await conn.fetchrow(
'''
SELECT id, username, display_name, created_at, password_hash
FROM users
WHERE username = $1
''',
username,
)
except Exception as exc:
if _db_down(exc):
raise unavailable('Хранилище недоступно') from None
raise
stored_hash = row['password_hash'] if row is not None else None
if not password_matches(stored_hash, password) or row is None:
return None
return _user(row)
async def create_session(self, user_id: str) -> Tuple[str, str]:
token = secrets.token_urlsafe(32)
expires = datetime.now(timezone.utc) + self._session_ttl
try:
async with self._pool.acquire() as conn:
await conn.execute(
'INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, $3)',
_token_key(token),
_as_uuid(user_id, 'Некорректный user_id'),
expires,
)
except Exception as exc:
if _db_down(exc):
raise unavailable('Хранилище недоступно') from None
raise
return token, _stamp(expires)
async def user_for_token(self, token: str) -> Optional[User]:
now = datetime.now(timezone.utc)
key = _token_key(token)
try:
async with self._pool.acquire() as conn:
row = await conn.fetchrow(
'''
SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
FROM sessions s
JOIN users u ON u.id = s.user_id
WHERE s.token_hash = $1
''',
key,
)
if row is None:
return None
if row['expires_at'] <= now:
await conn.execute('DELETE FROM sessions WHERE token_hash = $1', key)
return None
return _user(row)
except Exception as exc:
if _db_down(exc):
raise unavailable('Хранилище недоступно') from None
raise
async def revoke_session(self, token: str) -> bool:
try:
async with self._pool.acquire() as conn:
row = await conn.fetchrow(
'''
DELETE FROM sessions
WHERE token_hash = $1 AND expires_at > $2
RETURNING token_hash
''',
_token_key(token),
datetime.now(timezone.utc),
)
except Exception as exc:
if _db_down(exc):
raise unavailable('Хранилище недоступно') from None
raise
return row is not None
async def create_chat(self, title: str, member_ids: Sequence[str]) -> Chat:
ids = [_as_uuid(member_id, 'Некорректный user_id') for member_id in member_ids]
chat_id = uuid.uuid4()
created = self._now()
async with self._pool.acquire() as conn:
async with conn.transaction():
found = await conn.fetch('SELECT id FROM users WHERE id = ANY($1::uuid[])', ids)
if len(found) != len(ids):
raise invalid_request('Все участники должны быть существующими пользователями')
await conn.execute(
'INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)',
chat_id,
title,
created,
)
await conn.execute(
'''
INSERT INTO chat_members (chat_id, user_id, position)
SELECT $1, member_id, (ordinality - 1)::integer
FROM unnest($2::uuid[]) WITH ORDINALITY AS members(member_id, ordinality)
''',
chat_id,
ids,
)
return Chat(str(chat_id), title, tuple(member_ids), _stamp(created))
async def find_chat(self, chat_id: str, member_id: str) -> Optional[Chat]:
"""A chat of somebody else is indistinguishable from a missing one."""
chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id')
member_uuid = _as_uuid(member_id, 'Некорректный user_id')
async with self._pool.acquire() as conn:
row = await conn.fetchrow(
'''
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $2
WHERE c.id = $1
''',
chat_uuid,
member_uuid,
)
if row is None:
return None
members = await self._members(conn, [chat_uuid])
return Chat(str(row['id']), row['title'], members.get(chat_uuid, ()), _stamp(row['created_at']))
async def list_chats(self, member_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Chat], bool]:
member_uuid = _as_uuid(member_id, 'Некорректный user_id')
after_at, after_id = self._cursor(after)
async with self._pool.acquire() as conn:
if after_at is None:
rows = await conn.fetch(
'''
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $1
ORDER BY c.created_at, c.id
LIMIT $2
''',
member_uuid,
limit + 1,
)
else:
rows = await conn.fetch(
'''
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $1
WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid)
ORDER BY c.created_at, c.id
LIMIT $4
''',
member_uuid,
after_at,
after_id,
limit + 1,
)
page = rows[:limit]
members = await self._members(conn, [row['id'] for row in page])
chats = [
Chat(str(row['id']), row['title'], members.get(row['id'], ()), _stamp(row['created_at']))
for row in page
]
return chats, len(rows) > limit
async def create_attachment(
self,
chat_id: str,
owner_id: str,
filename: str,
content_type: str,
body: bytes,
sha256: str,
) -> Attachment:
chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id')
owner_uuid = _as_uuid(owner_id, 'Некорректный user_id')
attachment_id = uuid.uuid4()
created = self._now()
async with self._pool.acquire() as conn:
await conn.execute(
'''
INSERT INTO attachments (
id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
object_key, body, created_at, updated_at
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $10)
''',
attachment_id,
chat_uuid,
owner_uuid,
filename,
content_type,
len(body),
sha256,
uuid.uuid4().hex,
body,
created,
)
stamp = _stamp(created)
return Attachment(
str(attachment_id),
str(chat_uuid),
str(owner_uuid),
filename,
content_type,
len(body),
sha256,
stamp,
stamp,
)
async def find_attachment(self, attachment_id: str, user_id: str) -> Optional[Attachment]:
"""Metadata for a chat member. Missing and foreign attachments are both absent."""
attachment_uuid = _as_uuid(attachment_id, 'Некорректный attachment_id')
user_uuid = _as_uuid(user_id, 'Некорректный user_id')
async with self._pool.acquire() as conn:
row = await conn.fetchrow(
'''
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type,
a.size_bytes, a.sha256, a.created_at, a.updated_at
FROM attachments a
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
WHERE a.id = $1
''',
attachment_uuid,
user_uuid,
)
if row is None:
return None
return Attachment(
str(row['id']),
str(row['chat_id']),
str(row['owner_id']),
row['filename'],
row['content_type'],
row['size_bytes'],
row['sha256'],
_stamp(row['created_at']),
_stamp(row['updated_at']),
)
async def read_original(self, attachment_id: str, user_id: str) -> Optional[Tuple[str, bytes]]:
attachment_uuid = _as_uuid(attachment_id, 'Некорректный attachment_id')
user_uuid = _as_uuid(user_id, 'Некорректный user_id')
async with self._pool.acquire() as conn:
row = await conn.fetchrow(
'''
SELECT a.content_type, a.body
FROM attachments a
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
WHERE a.id = $1
''',
attachment_uuid,
user_uuid,
)
if row is None:
return None
return row['content_type'], bytes(row['body'])
async def add_message(
self,
chat_id: str,
sender_id: str,
text: str,
attachment_ids: Sequence[str],
*,
path: str,
key: str,
request_hash: str,
) -> Message:
"""Exactly one message per (sender, POST, path, key), whichever replica receives the request.
Concurrent duplicates block on the primary key of idempotency_keys until the first
transaction commits or rolls back, so a rolled-back attempt leaves the key free.
"""
chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id')
sender_uuid = _as_uuid(sender_id, 'Некорректный user_id')
linked = tuple(_as_uuid(item, 'Некорректный attachment_id') for item in attachment_ids)
message = Message(
str(uuid.uuid4()),
str(chat_uuid),
sender_id,
text,
_stamp(self._now()),
tuple(str(item) for item in linked),
)
cutoff = datetime.now(timezone.utc) - self._idempotency_ttl
async with self._pool.acquire() as conn:
async with conn.transaction():
await conn.execute(
'''
DELETE FROM idempotency_keys
WHERE user_id = $1 AND method = 'POST' AND path = $2 AND key = $3 AND created_at < $4
''',
sender_uuid,
path,
key,
cutoff,
)
claimed = await conn.fetchval(
'''
INSERT INTO idempotency_keys (user_id, method, path, key, request_hash, status_code, response)
VALUES ($1, 'POST', $2, $3, $4, 201, $5::jsonb)
ON CONFLICT (user_id, method, path, key) DO NOTHING
RETURNING 1
''',
sender_uuid,
path,
key,
request_hash,
json.dumps(message.to_dict()),
)
if claimed is None:
return await self._replay(conn, sender_uuid, path, key, request_hash)
if linked:
rows = await conn.fetch(
'SELECT id, chat_id FROM attachments WHERE id = ANY($1::uuid[])',
list(linked),
)
found = {row['id']: row['chat_id'] for row in rows}
if len(found) != len(linked) or any(found[item] != chat_uuid for item in linked):
raise not_found('Вложение не найдено')
await conn.execute(
'''
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, $5)
''',
uuid.UUID(message.id),
chat_uuid,
sender_uuid,
text,
_parse_stamp(message.created_at),
)
if linked:
await conn.executemany(
'''
INSERT INTO message_attachments (message_id, attachment_id, position)
VALUES ($1, $2, $3)
''',
[(uuid.UUID(message.id), item, index) for index, item in enumerate(linked)],
)
return message
async def _replay(
self,
conn: asyncpg.Connection,
sender_uuid: uuid.UUID,
path: str,
key: str,
request_hash: str,
) -> Message:
row = await conn.fetchrow(
'''
SELECT request_hash, response
FROM idempotency_keys
WHERE user_id = $1 AND method = 'POST' AND path = $2 AND key = $3
''',
sender_uuid,
path,
key,
)
if row is None:
raise unavailable('Повторите запрос с тем же Idempotency-Key')
if row['request_hash'] != request_hash:
raise conflict('Idempotency-Key уже использован с другим сообщением')
data = json.loads(row['response'])
return Message(
data['id'],
data['chat_id'],
data['sender_id'],
data['text'],
data['created_at'],
tuple(data.get('attachment_ids') or ()),
)
async def list_messages(self, chat_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Message], bool]:
chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id')
after_at, after_id = self._cursor(after)
async with self._pool.acquire() as conn:
if after_at is None:
rows = await conn.fetch(
'''
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
ORDER BY created_at, id
LIMIT $2
''',
chat_uuid,
limit + 1,
)
else:
rows = await conn.fetch(
'''
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
AND (created_at, id) > ($2::timestamptz, $3::uuid)
ORDER BY created_at, id
LIMIT $4
''',
chat_uuid,
after_at,
after_id,
limit + 1,
)
page = rows[:limit]
links = await self._attachment_ids(conn, [row['id'] for row in page])
messages = [
Message(
str(row['id']),
str(row['chat_id']),
str(row['sender_id']),
row['text'],
_stamp(row['created_at']),
links.get(row['id'], ()),
)
for row in page
]
return messages, len(rows) > limit
async def _attachment_ids(
self,
conn: asyncpg.Connection,
message_ids: Sequence[uuid.UUID],
) -> Dict[uuid.UUID, Tuple[str, ...]]:
if not message_ids:
return {}
rows = await conn.fetch(
'''
SELECT message_id, attachment_id
FROM message_attachments
WHERE message_id = ANY($1::uuid[])
ORDER BY message_id, position
''',
list(message_ids),
)
grouped: Dict[uuid.UUID, List[str]] = {}
for row in rows:
grouped.setdefault(row['message_id'], []).append(str(row['attachment_id']))
return {message_id: tuple(ids) for message_id, ids in grouped.items()}
async def _members(self, conn: asyncpg.Connection, chat_ids: Sequence[uuid.UUID]) -> Dict[uuid.UUID, Tuple[str, ...]]:
if not chat_ids:
return {}
rows = await conn.fetch(
'''
SELECT chat_id, user_id
FROM chat_members
WHERE chat_id = ANY($1::uuid[])
ORDER BY chat_id, position
''',
list(chat_ids),
)
grouped: Dict[uuid.UUID, List[str]] = {}
for row in rows:
grouped.setdefault(row['chat_id'], []).append(str(row['user_id']))
return {chat_id: tuple(member_ids) for chat_id, member_ids in grouped.items()}
def _cursor(self, after: Optional[Key]) -> Tuple[Optional[datetime], Optional[uuid.UUID]]:
if after is None:
return None, None
try:
return _parse_stamp(after[0]), uuid.UUID(after[1])
except ValueError:
raise invalid_request('Некорректный cursor') from None
+165
View File
@@ -0,0 +1,165 @@
# Client -> lb (HAProxy) -> api x API_REPLICAS -> postgres.
# Only the LB publishes a port. Networks: edge = lb<->api, data = api/migrate<->postgres (no LB, no internet).
# The DB password comes from .env (not committed) as a Compose secret file, never as a container env var.
name: messenger-lab4
x-db-client: &db-client
APP_ENV: ${APP_ENV:-lab}
LOG_LEVEL: ${LOG_LEVEL:-info}
DB_HOST: postgres
DB_USER: ${POSTGRES_USER:?set in .env}
DB_NAME: ${POSTGRES_DB:?set in .env}
DB_PASSWORD_FILE: /run/secrets/postgres_password
x-app-build: &app-build
context: .
dockerfile: Dockerfile
args:
APP_VERSION: ${APP_VERSION:-dev}
services:
postgres:
image: postgres:16.10-alpine@sha256:029660641a0cfc575b14f336ba448fb8a75fd595d42e1fa316b9fb4378742297
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
POSTGRES_DB: ${POSTGRES_DB}
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
networks:
- data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U \"$$POSTGRES_USER\" -d \"$$POSTGRES_DB\""]
interval: 2s
timeout: 5s
retries: 30
deploy:
resources:
limits:
cpus: "${POSTGRES_CPUS:-1.0}"
memory: "${POSTGRES_MEMORY:-512M}"
reservations:
cpus: "0.25"
memory: 256M
restart: unless-stopped
# One-shot schema step. Replicas never migrate on startup, so there is no race between them;
# an advisory lock additionally serializes accidental parallel runs.
migrate:
image: messenger-lab4-app:${APP_VERSION:-dev}
build: *app-build
command: ["python", "-m", "app.migrate"]
environment:
<<: *db-client
secrets:
- source: postgres_password
uid: "10001"
gid: "10001"
mode: 0400
networks:
- data
depends_on:
postgres:
condition: service_healthy
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
restart: "no"
api:
image: messenger-lab4-app:${APP_VERSION:-dev}
build: *app-build
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits:
cpus: "${API_CPUS:-1.0}"
memory: "${API_MEMORY:-256M}"
reservations:
cpus: "0.25"
memory: 128M
environment:
<<: *db-client
APP_HOST: 0.0.0.0
APP_PORT: "8080"
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
DRAIN_SECONDS: ${DRAIN_SECONDS:-4}
SHUTDOWN_TIMEOUT_SECONDS: ${SHUTDOWN_TIMEOUT_SECONDS:-3}
DB_POOL_MIN: ${DB_POOL_MIN:-1}
DB_POOL_MAX: ${DB_POOL_MAX:-10}
secrets:
- source: postgres_password
uid: "10001"
gid: "10001"
mode: 0400
networks:
- edge
- data
expose:
- "8080"
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
# Docker health gates startup order and rolling update; the LB runs its own checks (infra/haproxy/haproxy.cfg).
healthcheck:
test:
- CMD
- python
- -c
- import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)
interval: 3s
timeout: 3s
retries: 3
start_period: 20s
# SIGTERM -> readiness 503 for DRAIN_SECONDS (LB drops the replica in <= 3 s) -> uvicorn finishes
# in-flight requests within SHUTDOWN_TIMEOUT_SECONDS. 4 + 3 < 10, so SIGKILL is not reached.
stop_signal: SIGTERM
stop_grace_period: 10s
restart: unless-stopped
lb:
image: haproxy:3.2.26-alpine@sha256:96ec3c75a9264ba94e733eeacb44051ed6e7b79bb77a73c2c36f236b6423f1f0
# Loopback only. Both families: on Windows "localhost" tries ::1 first and waits ~2 s if nothing listens.
ports:
- "127.0.0.1:${LB_PORT:-8080}:8080"
- "[::1]:${LB_PORT:-8080}:8080"
volumes:
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
networks:
- edge
depends_on:
api:
condition: service_healthy
healthcheck:
test: ["CMD", "wget", "-qO-", "http://127.0.0.1:8080/lb/health"]
interval: 5s
timeout: 3s
retries: 3
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
reservations:
cpus: "0.1"
memory: 32M
restart: unless-stopped
networks:
edge: {}
data:
internal: true
secrets:
postgres_password:
environment: POSTGRES_PASSWORD
volumes:
pgdata:
+80
View File
@@ -0,0 +1,80 @@
# Client -> HAProxy -> api x N. Replicas are discovered through Docker DNS and checked actively.
#
# Timing contract (keep in sync with compose.yaml and app settings):
# check period inter 1s, timeout check 1s
# marked DOWN after fall 2 failed checks -> hung/draining replica leaves the pool in <= 3 s
# marked UP after rise 2 good checks -> new replica gets traffic ~2 s after it is ready
# DNS refresh every 1 s (hold valid 1s); a removed container disappears within ~1-2 s
# crashed process connect refused -> request redispatched to another replica at once
# app DRAIN_SECONDS=4 > 3 s, so a replica receiving SIGTERM is out of rotation before it closes its socket.
global
log stdout format raw local0 info
maxconn 2048
# Runtime API for evidence (scripts/lb-status.sh); loopback inside the container only.
stats socket ipv4@127.0.0.1:9999 level operator
resolvers docker
nameserver dns 127.0.0.11:53
accepted_payload_size 8192
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 1s
hold other 1s
hold refused 1s
hold nx 1s
hold timeout 1s
hold obsolete 0s
defaults
mode http
log global
option httplog
option dontlognull
option forwardfor
timeout connect 1s
timeout client 30s
timeout server 10s
timeout http-request 10s
timeout http-keep-alive 5s
timeout queue 2s
timeout check 1s
# A request whose connection to a replica failed is sent to another replica.
retries 2
option redispatch 1
frontend public
bind :8080
monitor-uri /lb/health
# Attachment uploads are raw bytes, up to 10 MiB. Larger declared bodies never reach an API replica.
http-request deny deny_status 413 if { req.hdr_val(content-length) gt 10485760 }
# Message POST carries a mandatory Idempotency-Key, so replaying it on another replica is safe.
# Other POSTs (users, chats, sessions) are retried only when the connection was never established.
acl message_post method POST
acl message_post_path path_reg ^/api/v1/chats/[^/]+/messages$
http-request disable-l7-retry if message_post !message_post_path
default_backend api
backend api
# Round robin, no stickiness: any replica serves any session from PostgreSQL.
balance roundrobin
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host lb
http-check expect status 200
retry-on conn-failure empty-response response-timeout
http-error status 503 content-type application/json string "{\"error\":{\"code\":\"unavailable\",\"message\":\"No API replica is available\",\"request_id\":\"lb\"}}"
http-error status 502 content-type application/json string "{\"error\":{\"code\":\"internal_error\",\"message\":\"Bad gateway\",\"request_id\":\"lb\"}}"
http-error status 504 content-type application/json string "{\"error\":{\"code\":\"internal_error\",\"message\":\"Gateway timeout\",\"request_id\":\"lb\"}}"
default-server check inter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none
server-template api 1-10 api:8080
# Read-only stats for evidence; not published, reachable only inside the container.
frontend stats
bind 127.0.0.1:8404
stats enable
stats uri /stats
stats refresh 5s
http-request set-log-level silent
+53
View File
@@ -0,0 +1,53 @@
-- Initial schema. The runner records this file in schema_migrations and skips it on the next start.
CREATE TABLE IF NOT EXISTS schema_migrations (
version TEXT PRIMARY KEY,
applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
CONSTRAINT users_username_unique UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE sessions (
token_hash TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users (id),
expires_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats (id),
user_id UUID NOT NULL REFERENCES users (id),
position INTEGER NOT NULL,
PRIMARY KEY (chat_id, user_id),
CONSTRAINT chat_members_position_nonnegative CHECK (position >= 0)
);
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats (id),
sender_id UUID NOT NULL REFERENCES users (id),
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
);
-- Keyset history: WHERE chat_id = ? AND (created_at, id) > cursor ORDER BY created_at, id.
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
-- Chat list is filtered by the caller, then ordered by the chat's own (created_at, id).
CREATE INDEX chat_members_user_idx ON chat_members (user_id);
+16
View File
@@ -0,0 +1,16 @@
-- Result of POST /chats/{id}/messages per (user, method, path, Idempotency-Key).
-- The row and the message are written in one transaction, so a failed attempt leaves no key behind.
CREATE TABLE idempotency_keys (
user_id UUID NOT NULL REFERENCES users (id),
method TEXT NOT NULL,
path TEXT NOT NULL,
key TEXT NOT NULL,
request_hash TEXT NOT NULL,
status_code INTEGER NOT NULL,
response JSONB NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (user_id, method, path, key),
CONSTRAINT idempotency_keys_key_format CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$')
);
CREATE INDEX idempotency_keys_created_idx ON idempotency_keys (created_at);
+4
View File
@@ -0,0 +1,4 @@
-- Expand-only: new indexes, no column/table removal or rename, so replicas of the previous build keep working
-- while the rolling update is in progress. Destructive changes go to a later release, after old replicas are gone.
CREATE INDEX IF NOT EXISTS sessions_user_idx ON sessions (user_id);
CREATE INDEX IF NOT EXISTS sessions_expires_idx ON sessions (expires_at);
+38
View File
@@ -0,0 +1,38 @@
-- Lab4: message may be text, attachments, or both. Empty text is stored only when
-- an attachment is linked; the API rejects a blank message that has neither.
ALTER TABLE messages DROP CONSTRAINT messages_text_len;
ALTER TABLE messages ADD CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 0 AND 4000);
-- filename is the display name. object_key is assigned by the server and is never taken from filename.
-- The original bytes sit next to the metadata so any API replica can read them.
CREATE TABLE attachments (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats (id),
owner_id UUID NOT NULL REFERENCES users (id),
filename TEXT NOT NULL,
content_type TEXT NOT NULL,
size_bytes INTEGER NOT NULL,
sha256 TEXT NOT NULL,
object_key TEXT NOT NULL,
body BYTEA NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255),
CONSTRAINT attachments_content_type CHECK (content_type IN ('image/png', 'image/jpeg')),
CONSTRAINT attachments_size CHECK (size_bytes BETWEEN 1 AND 10485760),
CONSTRAINT attachments_sha256 CHECK (sha256 ~ '^[a-f0-9]{64}$'),
CONSTRAINT attachments_object_key_unique UNIQUE (object_key),
CONSTRAINT attachments_body_len CHECK (octet_length(body) = size_bytes)
);
CREATE INDEX attachments_chat_idx ON attachments (chat_id);
CREATE TABLE message_attachments (
message_id UUID NOT NULL REFERENCES messages (id),
attachment_id UUID NOT NULL REFERENCES attachments (id),
position INTEGER NOT NULL,
PRIMARY KEY (message_id, attachment_id),
CONSTRAINT message_attachments_position CHECK (position >= 0 AND position < 10)
);
CREATE INDEX message_attachments_message_idx ON message_attachments (message_id, position);
+19
View File
@@ -0,0 +1,19 @@
# Direct: fastapi, pydantic, uvicorn, argon2-cffi. The rest are their dependencies, pinned.
asyncpg==0.32.0
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi==25.1.0
argon2-cffi-bindings==25.1.0
cffi==2.0.0
click==8.5.0
fastapi==0.141.1
h11==0.16.0
idna==3.20
pycparser==3.0
pydantic==2.13.5
pydantic_core==2.46.5
starlette==1.7.0
typing-inspection==0.4.4
typing_extensions==4.16.0
uvicorn==0.53.0
+8
View File
@@ -0,0 +1,8 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# Restart the LB, every API replica and PostgreSQL. The pgdata volume stays; nothing is re-seeded.
docker compose --env-file .env stop lb api
docker compose --env-file .env restart postgres
# Brings back all replicas (including one left stopped by stop-one.sh); migrate re-runs as a no-op.
docker compose --env-file .env up -d --wait
+29
View File
@@ -0,0 +1,29 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
# Stop exactly ONE API replica and leave it stopped. DB, LB and volumes are untouched.
# X-Instance-Id is the container hostname, i.e. the short Docker container ID.
# Restore afterwards with: docker compose --env-file .env up -d --wait
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
case "$TARGET_INSTANCE_ID" in
*[!0-9a-f]*) valid=no ;;
*) valid=yes ;;
esac
if [ "$valid" = no ] || [ "${#TARGET_INSTANCE_ID}" -lt 12 ]; then
echo "TARGET_INSTANCE_ID is not a container ID" >&2
exit 2
fi
project="${COMPOSE_PROJECT_NAME:-messenger-lab4}"
matches=$(docker ps -q --no-trunc \
--filter "label=com.docker.compose.project=$project" \
--filter "label=com.docker.compose.service=api" | grep "^$TARGET_INSTANCE_ID" || true)
count=$(printf '%s' "$matches" | grep -c . || true)
if [ "$count" -ne 1 ]; then
echo "expected one running api container for $TARGET_INSTANCE_ID, found $count" >&2
exit 1
fi
name=$(docker inspect --format '{{.Name}}' "$matches")
# Graceful: SIGTERM -> 4 s drain (readiness 503, LB drops it) -> <= 3 s in-flight finish.
# SIGKILL only after 9 s, so the hook still returns before the test's 10 s limit.
docker stop --time 9 "$matches" >/dev/null
echo "stopped api replica ${name#/} ($TARGET_INSTANCE_ID)"