From 0e70320df3d8428177b39d102fa9232dd21a561e Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Thu, 29 Oct 2026 14:14:26 +0300 Subject: [PATCH 1/8] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B5=D0=BD=D0=B5=D1=81?= =?UTF-8?q?=D1=82=D0=B8=20API=20=D0=BD=D0=B0=20PostgreSQL,=20=D0=B4=D0=BE?= =?UTF-8?q?=D0=B1=D0=B0=D0=B2=D0=B8=D1=82=D1=8C=20=D1=81=D0=B5=D1=81=D1=81?= =?UTF-8?q?=D0=B8=D0=B8=20Basic/Bearer=20=D0=B8=20=D0=BA=D1=8D=D1=88=20Val?= =?UTF-8?q?key?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .dockerignore | 12 +++ Dockerfile | 25 +++++++ migrations/0001_init.sql | 46 ++++++++++++ requirements.txt | 19 +++++ src/app.py | 155 +++++++++++++++++++++++++++++++++++++++ src/auth.py | 92 +++++++++++++++++++++++ src/cache.py | 60 +++++++++++++++ src/config.py | 37 ++++++++++ src/db.py | 25 +++++++ src/errors.py | 37 ++++++++++ src/main.py | 22 ++++++ src/migrate.py | 47 ++++++++++++ src/models.py | 41 +++++++++++ src/pagination.py | 31 ++++++++ src/store.py | 143 ++++++++++++++++++++++++++++++++++++ 15 files changed, 792 insertions(+) create mode 100644 Dockerfile create mode 100644 migrations/0001_init.sql create mode 100644 requirements.txt create mode 100644 src/app.py create mode 100644 src/auth.py create mode 100644 src/cache.py create mode 100644 src/config.py create mode 100644 src/db.py create mode 100644 src/errors.py create mode 100644 src/main.py create mode 100644 src/migrate.py create mode 100644 src/models.py create mode 100644 src/pagination.py create mode 100644 src/store.py diff --git a/.dockerignore b/.dockerignore index bc16e556..93f3500f 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,15 @@ __pycache__ node_modules evidence .DS_Store +tests +student-tests +contracts +scripts +examples +*.md +Makefile +lab.json +requirements-dev.txt +Dockerfile* +.dockerignore +.gitignore diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..5ac5014f --- /dev/null +++ b/Dockerfile @@ -0,0 +1,25 @@ +FROM python:3.12.15-slim-trixie@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 \ + PIP_ROOT_USER_ACTION=ignore + +WORKDIR /app + +COPY requirements.txt . +RUN pip install -r requirements.txt + +COPY migrations/ ./migrations/ +COPY src/ ./src/ + +RUN useradd --uid 10001 --user-group --no-create-home --shell /usr/sbin/nologin app +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ.get('APP_PORT', '8080'), timeout=2)"] + +CMD ["python", "src/main.py"] diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..44c4ed38 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,46 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_by uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + position smallint NOT NULL CHECK (position >= 1), + PRIMARY KEY (chat_id, user_id), + UNIQUE (chat_id, position) +); + +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id uuid NOT NULL, + sender_id uuid NOT NULL, + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members (chat_id, user_id) +); + +CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32), + user_id uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT now(), + expires_at timestamptz NOT NULL, + CHECK (expires_at > created_at) +); + +CREATE INDEX sessions_user_idx ON sessions (user_id); +CREATE INDEX sessions_expires_idx ON sessions (expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..0313e9df --- /dev/null +++ b/requirements.txt @@ -0,0 +1,19 @@ +annotated-types==0.8.0 +anyio==4.15.1 +argon2-cffi==25.1.0 +argon2-cffi-bindings==26.1.0 +cffi==2.1.1 +click==8.5.0 +fastapi==0.115.6 +h11==0.16.0 +idna==3.20 +psycopg==3.3.6 +psycopg-binary==3.3.6 +psycopg-pool==3.3.3 +pycparser==3.12 +pydantic==2.10.4 +pydantic_core==2.27.2 +redis==8.1.0 +starlette==0.41.3 +typing_extensions==4.16.0 +uvicorn==0.34.0 diff --git a/src/app.py b/src/app.py new file mode 100644 index 00000000..0ceb7382 --- /dev/null +++ b/src/app.py @@ -0,0 +1,155 @@ +from contextlib import asynccontextmanager +import logging +import time +from typing import Annotated, Optional +import uuid + +from fastapi import Depends, FastAPI, Header, Query, Request, Response +from fastapi.exceptions import RequestValidationError +import psycopg +from starlette.exceptions import HTTPException as StarletteHTTPException + +import auth +from cache import cache +from db import pool +from errors import ApiError, error_response +from models import CreateChat, CreateMessage, CreateUser +import store + +log = logging.getLogger('messenger') + +Limit = Annotated[int, Query(ge=1, le=100)] +Cursor = Annotated[Optional[str], Query(min_length=1)] + +state = {'ready': False} + + +@asynccontextmanager +async def lifespan(app): + pool.open(wait=False) + log.info('session cache: %s', 'valkey' if cache.client else 'disabled') + state['ready'] = True + log.info('application started') + yield + state['ready'] = False + log.info('application stopping') + pool.close(timeout=2) + + +app = FastAPI(title='MTUSI Messenger lab2', lifespan=lifespan) + + +@app.middleware('http') +async def request_context(request: Request, call_next): + request.state.request_id = uuid.uuid4().hex + started = time.perf_counter() + try: + response = await call_next(request) + except Exception: + log.exception('unhandled error request_id=%s', request.state.request_id) + response = error_response(request, 500, 'Внутренняя ошибка сервера') + response.headers['X-Request-Id'] = request.state.request_id + log.info('%s %s -> %d %.1fms request_id=%s', request.method, request.url.path, + response.status_code, (time.perf_counter() - started) * 1000, request.state.request_id) + return response + + +@app.exception_handler(ApiError) +async def handle_api_error(request: Request, exc: ApiError): + return error_response(request, exc.status, exc.message, exc.headers) + + +@app.exception_handler(StarletteHTTPException) +async def handle_http_error(request: Request, exc: StarletteHTTPException): + messages = {404: 'Ресурс не найден', 405: 'Метод не поддерживается'} + return error_response(request, exc.status_code, messages.get(exc.status_code, 'Ошибка запроса')) + + +@app.exception_handler(RequestValidationError) +async def handle_validation_error(request: Request, exc: RequestValidationError): + errors = exc.errors() + where = '.'.join(str(part) for part in errors[0]['loc']) if errors else 'request' + return error_response(request, 400, 'Некорректный запрос: ' + where) + + +@app.exception_handler(psycopg.DataError) +async def handle_data_error(request: Request, exc: psycopg.DataError): + return error_response(request, 400, 'Некорректные данные') + + +@app.exception_handler(psycopg.OperationalError) +@app.exception_handler(psycopg.InterfaceError) +async def handle_database_unavailable(request: Request, exc: psycopg.Error): + log.warning('database unavailable: %s request_id=%s', type(exc).__name__, request.state.request_id) + return error_response(request, 503, 'Хранилище временно недоступно') + + +@app.get('/health/live') +async def liveness(): + return {'status': 'ok'} + + +@app.get('/health/ready') +def readiness(): + if not state['ready']: + raise ApiError(503, 'Сервис не готов') + with pool.connection(timeout=1) as conn: + conn.execute('SELECT 1') + return {'status': 'ok'} + + +def current_session(authorization: Annotated[Optional[str], Header()] = None): + return auth.authenticate(authorization) + + +def current_user(session: Annotated[dict, Depends(current_session)]): + return session['user'] + + +@app.post('/api/v1/users', status_code=201) +def register_user(body: CreateUser): + return store.create_user(body.username, body.display_name, auth.hash_password(body.password)) + + +@app.post('/api/v1/auth/sessions', status_code=201) +def create_session(request: Request, authorization: Annotated[Optional[str], Header()] = None): + if request.headers.get('content-length', '0') != '0' or 'transfer-encoding' in request.headers: + raise ApiError(400, 'Вход принимает только заголовок Authorization: Basic, без тела') + return auth.login(authorization) + + +@app.delete('/api/v1/auth/sessions/current', status_code=204) +def delete_session(session: Annotated[dict, Depends(current_session)]): + auth.logout(session) + return Response(status_code=204) + + +@app.get('/api/v1/users/me') +def get_me(user: Annotated[dict, Depends(current_user)]): + return user + + +@app.post('/api/v1/chats', status_code=201) +def create_chat(body: CreateChat, user: Annotated[dict, Depends(current_user)]): + return store.create_chat(user['id'], body.title, body.member_ids) + + +@app.get('/api/v1/chats') +def list_chats(user: Annotated[dict, Depends(current_user)], limit: Limit = 50, cursor: Cursor = None): + return store.list_chats(user['id'], cursor, limit) + + +@app.get('/api/v1/chats/{chat_id}') +def get_chat(chat_id: uuid.UUID, user: Annotated[dict, Depends(current_user)]): + return store.get_chat(str(chat_id), user['id']) + + +@app.post('/api/v1/chats/{chat_id}/messages', status_code=201) +def create_message(chat_id: uuid.UUID, body: CreateMessage, user: Annotated[dict, Depends(current_user)]): + return store.create_message(str(chat_id), user['id'], body.text) + + +@app.get('/api/v1/chats/{chat_id}/messages') +def list_messages(chat_id: uuid.UUID, user: Annotated[dict, Depends(current_user)], + limit: Limit = 50, cursor: Cursor = None): + return store.list_messages(str(chat_id), user['id'], cursor, limit) diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..62048f7e --- /dev/null +++ b/src/auth.py @@ -0,0 +1,92 @@ +import base64 +import binascii +import hashlib +import re +import secrets + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError + +from cache import cache +from config import settings +from db import iso +from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, unauthorized +import store + +USERNAME = re.compile(r'^[a-z0-9_]{3,32}$') + +hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) +DUMMY_HASH = hasher.hash('dummy-password-for-equal-timing') + + +def hash_password(password): + return hasher.hash(password) + + +def verify_password(password_hash, password): + try: + return hasher.verify(password_hash, password) + except (VerificationError, InvalidHashError): + return False + + +def token_hash(token): + return hashlib.sha256(token.encode('ascii')).digest() + + +def parse_credentials(header, scheme): + name, _, value = (header or '').strip().partition(' ') + value = value.strip() + if name.lower() != scheme or not value or ' ' in value: + return None + return value + + +def parse_basic(header): + value = parse_credentials(header, 'basic') + if value is None: + return None + try: + decoded = base64.b64decode(value, validate=True).decode('utf-8') + except (binascii.Error, UnicodeDecodeError): + return None + username, separator, password = decoded.partition(':') + if not separator or not USERNAME.match(username) or not 12 <= len(password) <= 128: + return None + return username, password + + +def login(header): + credentials = parse_basic(header) + row = store.find_credentials(credentials[0]) if credentials else None + if row is None: + verify_password(DUMMY_HASH, credentials[1] if credentials else 'x' * 12) + raise unauthorized(BASIC_CHALLENGE, 'Неверное имя пользователя или пароль') + if not verify_password(row['password_hash'], credentials[1]): + raise unauthorized(BASIC_CHALLENGE, 'Неверное имя пользователя или пароль') + token = secrets.token_urlsafe(32) + digest = token_hash(token) + expires_at = store.create_session(row['id'], digest, settings.session_ttl) + user = store.user_out(row) + cache.put(digest, user, expires_at) + return {'token': token, 'token_type': 'Bearer', 'expires_at': iso(expires_at), 'user': user} + + +def authenticate(header): + token = parse_credentials(header, 'bearer') + if token is None or not token.isascii(): + raise unauthorized(BEARER_CHALLENGE) + digest = token_hash(token) + user = cache.get(digest) + if user is None: + row = store.session_user(digest) + if row is None: + raise unauthorized(BEARER_CHALLENGE) + user = store.user_out(row) + cache.put(digest, user, row['expires_at']) + return {'user': user, 'token_hash': digest} + + +def logout(session): + store.delete_session(session['token_hash']) + cache.delete(session['token_hash']) diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..2c3a83fe --- /dev/null +++ b/src/cache.py @@ -0,0 +1,60 @@ +from datetime import datetime, timezone +import json +import logging +import time + +import redis + +from config import settings + +log = logging.getLogger('messenger.cache') + +BYPASS_SECONDS = 5 + + +class SessionCache: + def __init__(self, url, max_ttl): + self.client = redis.Redis.from_url(url, socket_timeout=0.2, socket_connect_timeout=0.2, + decode_responses=True) if url else None + self.max_ttl = max_ttl + self.bypass_until = 0.0 + + def _run(self, action): + if self.client is None or time.monotonic() < self.bypass_until: + return None + try: + return action(self.client) + except redis.RedisError as error: + log.warning('session cache unavailable (%s), using PostgreSQL for %ds', type(error).__name__, BYPASS_SECONDS) + self.bypass_until = time.monotonic() + BYPASS_SECONDS + return None + + @staticmethod + def key(token_hash): + return 'session:' + token_hash.hex() + + def get(self, token_hash): + raw = self._run(lambda c: c.get(self.key(token_hash))) + if not raw: + return None + entry = json.loads(raw) + if entry['expires_at'] <= time.time(): + return None + return entry['user'] + + def put(self, token_hash, user, expires_at: datetime): + remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds()) + ttl = min(self.max_ttl, remaining) + if ttl <= 0: + return + value = json.dumps({'user': user, 'expires_at': expires_at.timestamp()}, ensure_ascii=False) + self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl)) + + def delete(self, token_hash): + self._run(lambda c: c.delete(self.key(token_hash))) + + def ping(self): + return bool(self._run(lambda c: c.ping())) + + +cache = SessionCache(settings.cache_url, settings.session_cache_ttl) diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..f1308c10 --- /dev/null +++ b/src/config.py @@ -0,0 +1,37 @@ +import os + + +def setting(name, default=None): + path = os.environ.get(name + '_FILE') + if path: + with open(path, encoding='utf-8') as file: + return file.read().strip() + return os.environ.get(name, default) + + +def positive_int(name, default): + value = int(os.environ.get(name, default)) + if value <= 0: + raise SystemExit('%s must be a positive integer' % name) + return value + + +class Settings: + def __init__(self): + self.host = os.environ.get('APP_HOST', '0.0.0.0') + self.port = positive_int('APP_PORT', '8080') + self.env = os.environ.get('APP_ENV', 'lab') + self.shutdown_timeout = positive_int('APP_SHUTDOWN_TIMEOUT', '5') + self.database_url = setting('DATABASE_URL') + self.cache_url = setting('CACHE_URL') or None + self.session_ttl = positive_int('SESSION_TTL_SECONDS', '3600') + self.session_cache_ttl = positive_int('SESSION_CACHE_TTL_SECONDS', '60') + self.db_pool_min = positive_int('DB_POOL_MIN', '1') + self.db_pool_max = positive_int('DB_POOL_MAX', '10') + self.db_pool_timeout = float(os.environ.get('DB_POOL_TIMEOUT_SECONDS', '2')) + self.db_statement_timeout_ms = positive_int('DB_STATEMENT_TIMEOUT_MS', '5000') + if not self.database_url: + raise SystemExit('DATABASE_URL or DATABASE_URL_FILE is required') + + +settings = Settings() diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..c1dc8790 --- /dev/null +++ b/src/db.py @@ -0,0 +1,25 @@ +from datetime import timezone + +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + +from config import settings + +pool = ConnectionPool( + settings.database_url, + min_size=settings.db_pool_min, + max_size=settings.db_pool_max, + timeout=settings.db_pool_timeout, + check=ConnectionPool.check_connection, + open=False, + name='messenger', + kwargs={ + 'connect_timeout': 3, + 'row_factory': dict_row, + 'options': '-c timezone=UTC -c statement_timeout=%d' % settings.db_statement_timeout_ms, + }, +) + + +def iso(value): + return value.astimezone(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ') diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..5cbdbba5 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,37 @@ +from fastapi import Request +from fastapi.responses import JSONResponse + +CODES = { + 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', +} + +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' + + +class ApiError(Exception): + def __init__(self, status, message, headers=None): + super().__init__(message) + self.status = status + self.message = message + self.headers = headers + + +def unauthorized(challenge, message='Нужна действительная сессия'): + return ApiError(401, message, {'WWW-Authenticate': challenge}) + + +def error_response(request: Request, status, message, headers=None): + request_id = getattr(request.state, 'request_id', '-') + body = {'error': {'code': CODES.get(status, 'invalid_request'), 'message': message, 'request_id': request_id}} + if status == 401 and not headers: + headers = {'WWW-Authenticate': BEARER_CHALLENGE} + return JSONResponse(body, status_code=status, headers=headers) diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..f3f09365 --- /dev/null +++ b/src/main.py @@ -0,0 +1,22 @@ +import logging +import sys + +import uvicorn + +from config import settings + + +def main(): + logging.basicConfig(stream=sys.stdout, level=logging.INFO, + format='%(asctime)s %(levelname)s %(name)s: %(message)s') + logging.getLogger('messenger').info('config host=%s port=%d env=%s session_ttl=%ds session_cache_ttl=%ds', + settings.host, settings.port, settings.env, + settings.session_ttl, settings.session_cache_ttl) + + from app import app + uvicorn.run(app, host=settings.host, port=settings.port, access_log=False, log_config=None, + timeout_graceful_shutdown=settings.shutdown_timeout) + + +if __name__ == '__main__': + main() diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..7ac81bac --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,47 @@ +import logging +from pathlib import Path +import sys +import time + +import psycopg + +from config import settings + +MIGRATIONS = Path(__file__).resolve().parent.parent / 'migrations' +LOCK_ID = 20260002 + +log = logging.getLogger('migrate') + + +def connect(attempts=30): + for attempt in range(1, attempts + 1): + try: + return psycopg.connect(settings.database_url, autocommit=True, connect_timeout=3) + except psycopg.OperationalError: + if attempt == attempts: + raise + log.info('database is not ready, retry %d/%d', attempt, attempts) + time.sleep(1) + + +def main(): + logging.basicConfig(stream=sys.stdout, level=logging.INFO, format='%(asctime)s %(name)s: %(message)s') + with connect() as conn: + conn.execute('SELECT pg_advisory_lock(%s)', (LOCK_ID,)) + conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations (' + 'version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())') + applied = {row[0] for row in conn.execute('SELECT version FROM schema_migrations')} + for path in sorted(MIGRATIONS.glob('*.sql')): + if path.stem in applied: + log.info('skip %s: already applied', path.stem) + continue + with conn.transaction(): + conn.execute(path.read_text(encoding='utf-8')) + conn.execute('INSERT INTO schema_migrations (version) VALUES (%s)', (path.stem,)) + log.info('applied %s', path.stem) + conn.execute('SELECT pg_advisory_unlock(%s)', (LOCK_ID,)) + log.info('schema is up to date') + + +if __name__ == '__main__': + main() diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..31387bf4 --- /dev/null +++ b/src/models.py @@ -0,0 +1,41 @@ +from pydantic import BaseModel, ConfigDict, Field, field_validator + + +class StrictModel(BaseModel): + model_config = ConfigDict(extra='forbid', strict=True) + + +def not_blank(value): + if not value.strip(): + raise ValueError('must not be blank') + return value + + +class CreateUser(StrictModel): + username: str = Field(pattern=r'^[a-z0-9_]{3,32}$') + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator('display_name', 'password') + @classmethod + def not_blank_fields(cls, value): + return not_blank(value) + + +class CreateChat(StrictModel): + title: str = Field(min_length=1, max_length=100) + member_ids: list[str] = Field(min_length=1, max_length=100) + + @field_validator('title') + @classmethod + def title_not_blank(cls, value): + return not_blank(value) + + +class CreateMessage(StrictModel): + text: str = Field(min_length=1, max_length=4000) + + @field_validator('text') + @classmethod + def text_not_blank(cls, value): + return not_blank(value) diff --git a/src/pagination.py b/src/pagination.py new file mode 100644 index 00000000..81b08760 --- /dev/null +++ b/src/pagination.py @@ -0,0 +1,31 @@ +import base64 +from datetime import datetime +import json +import uuid + +from errors import ApiError + + +def encode_cursor(scope, item): + raw = json.dumps({'s': scope, 't': item['created_at'], 'i': item['id']}, separators=(',', ':')) + return base64.urlsafe_b64encode(raw.encode()).decode().rstrip('=') + + +def decode_cursor(scope, cursor): + try: + padded = cursor + '=' * (-len(cursor) % 4) + data = json.loads(base64.urlsafe_b64decode(padded.encode('ascii'))) + if data['s'] != scope or not isinstance(data['t'], str) or not isinstance(data['i'], str): + raise ValueError + created_at = datetime.fromisoformat(data['t']) + if created_at.tzinfo is None: + raise ValueError + return created_at, uuid.UUID(data['i']) + except (ValueError, TypeError, KeyError, AttributeError): + raise ApiError(400, 'Некорректный cursor') from None + + +def page(items, scope, limit): + chunk = items[:limit] + has_more = len(items) > limit + return {'items': chunk, 'next_cursor': encode_cursor(scope, chunk[-1]) if has_more else None} diff --git a/src/store.py b/src/store.py new file mode 100644 index 00000000..2203d583 --- /dev/null +++ b/src/store.py @@ -0,0 +1,143 @@ +import uuid + +from psycopg import errors + +from db import iso, pool +from errors import ApiError +from pagination import decode_cursor, page + +USER_COLUMNS = 'u.id, u.username, u.display_name, u.created_at' +MESSAGE_COLUMNS = 'id, chat_id, sender_id, text, created_at' +CHAT_SELECT = ('SELECT c.id, c.title, c.created_at, ' + 'ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id = c.id ORDER BY m.position) AS member_ids ' + 'FROM chats c ') + + +def user_out(row): + return {'id': str(row['id']), 'username': row['username'], + 'display_name': row['display_name'], 'created_at': iso(row['created_at'])} + + +def chat_out(row): + return {'id': str(row['id']), 'title': row['title'], + 'member_ids': [str(m) for m in row['member_ids']], 'created_at': iso(row['created_at'])} + + +def message_out(row): + return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'sender_id': str(row['sender_id']), + 'text': row['text'], 'created_at': iso(row['created_at'])} + + +def create_user(username, display_name, password_hash): + try: + with pool.connection() as conn: + row = conn.execute( + 'INSERT INTO users AS u (username, display_name, password_hash) VALUES (%s, %s, %s) ' + 'RETURNING ' + USER_COLUMNS, + (username, display_name, password_hash)).fetchone() + except errors.UniqueViolation: + raise ApiError(409, 'Имя пользователя уже занято') from None + return user_out(row) + + +def find_credentials(username): + with pool.connection() as conn: + return conn.execute('SELECT ' + USER_COLUMNS + ', u.password_hash FROM users u WHERE u.username = %s', + (username,)).fetchone() + + +def create_session(user_id, token_hash, ttl_seconds): + with pool.connection() as conn: + conn.execute('DELETE FROM sessions WHERE user_id = %s AND expires_at <= now()', (user_id,)) + return conn.execute( + 'INSERT INTO sessions (token_hash, user_id, expires_at) ' + 'VALUES (%s, %s, now() + make_interval(secs => %s)) RETURNING expires_at', + (token_hash, user_id, ttl_seconds)).fetchone()['expires_at'] + + +def session_user(token_hash): + with pool.connection() as conn: + return conn.execute( + 'SELECT ' + USER_COLUMNS + ', s.expires_at FROM sessions s JOIN users u ON u.id = s.user_id ' + 'WHERE s.token_hash = %s AND s.expires_at > now()', + (token_hash,)).fetchone() + + +def delete_session(token_hash): + with pool.connection() as conn: + conn.execute('DELETE FROM sessions WHERE token_hash = %s', (token_hash,)) + + +def create_chat(creator_id, title, member_ids): + try: + members = [str(uuid.UUID(m)) for m in member_ids] + except ValueError: + raise ApiError(400, 'Неизвестный участник чата') from None + if len(set(members)) != len(members): + raise ApiError(400, 'Участники не должны повторяться') + if creator_id not in members: + raise ApiError(400, 'Создатель должен быть участником чата') + try: + with pool.connection() as conn, conn.transaction(): + chat = conn.execute('INSERT INTO chats (title, created_by) VALUES (%s, %s) RETURNING id, title, created_at', + (title, creator_id)).fetchone() + conn.execute('INSERT INTO chat_members (chat_id, user_id, position) ' + 'SELECT %s, member, position FROM unnest(%s::uuid[]) WITH ORDINALITY AS t(member, position)', + (chat['id'], members)) + except errors.ForeignKeyViolation: + raise ApiError(400, 'Неизвестный участник чата') from None + return chat_out({**chat, 'member_ids': members}) + + +def get_chat(chat_id, user_id): + with pool.connection() as conn: + row = conn.execute(CHAT_SELECT + 'JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s ' + 'WHERE c.id = %s', (user_id, chat_id)).fetchone() + if row is None: + raise ApiError(404, 'Чат не найден') + return chat_out(row) + + +def list_chats(user_id, cursor, limit): + scope = 'user:' + user_id + sql = CHAT_SELECT + 'JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s ' + params = [user_id] + if cursor: + sql += 'AND (c.created_at, c.id) > (%s, %s) ' + params += decode_cursor(scope, cursor) + sql += 'ORDER BY c.created_at, c.id LIMIT %s' + with pool.connection() as conn: + rows = conn.execute(sql, params + [limit + 1]).fetchall() + return page([chat_out(r) for r in rows], scope, limit) + + +def is_member(conn, chat_id, user_id): + return conn.execute('SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s', + (chat_id, user_id)).fetchone() is not None + + +def create_message(chat_id, sender_id, text): + with pool.connection() as conn: + row = conn.execute( + 'INSERT INTO messages (chat_id, sender_id, text) SELECT %s, %s, %s ' + 'WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s) ' + 'RETURNING ' + MESSAGE_COLUMNS, + (chat_id, sender_id, text, chat_id, sender_id)).fetchone() + if row is None: + raise ApiError(404, 'Чат не найден') + return message_out(row) + + +def list_messages(chat_id, user_id, cursor, limit): + scope = 'chat:' + chat_id + sql = 'SELECT ' + MESSAGE_COLUMNS + ' FROM messages WHERE chat_id = %s ' + params = [chat_id] + if cursor: + sql += 'AND (created_at, id) > (%s, %s) ' + params += decode_cursor(scope, cursor) + sql += 'ORDER BY created_at, id LIMIT %s' + with pool.connection() as conn: + if not is_member(conn, chat_id, user_id): + raise ApiError(404, 'Чат не найден') + rows = conn.execute(sql, params + [limit + 1]).fetchall() + return page([message_out(r) for r in rows], scope, limit) -- 2.54.0 From 5610e2326f85f30edf5b009a5a5668fb738c8ba4 Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Thu, 29 Oct 2026 14:14:27 +0300 Subject: [PATCH 2/8] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20compose-=D1=81=D1=82=D0=B5=D0=BD=D0=B4,=20=D1=81=D0=B5?= =?UTF-8?q?=D0=BA=D1=80=D0=B5=D1=82=D1=8B=20=D0=B8=20restart=20hook?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 14 +++-- Makefile | 5 +- compose.yaml | 125 ++++++++++++++++++++++++++++++++++++++++ scripts/init_secrets.py | 28 +++++++++ scripts/restart.cmd | 6 ++ scripts/restart.sh | 7 +++ 6 files changed, 180 insertions(+), 5 deletions(-) create mode 100644 compose.yaml create mode 100644 scripts/init_secrets.py create mode 100644 scripts/restart.cmd create mode 100755 scripts/restart.sh diff --git a/.env.example b/.env.example index 714c8076..df36c46d 100644 --- a/.env.example +++ b/.env.example @@ -3,9 +3,15 @@ APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab +APP_SHUTDOWN_TIMEOUT=5 SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. +# Credentials are generated locally by: python scripts/init_secrets.py +# 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 +# Sessions: PostgreSQL is the source of truth, Valkey is a read-through cache. +CACHE_URL=redis://valkey:6379/0 +SESSION_CACHE_TTL_SECONDS=60 +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_POOL_TIMEOUT_SECONDS=2 +DB_STATEMENT_TIMEOUT_MS=5000 diff --git a/Makefile b/Makefile index 9ecb223e..a8372e57 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence student-test help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -18,6 +18,9 @@ validate: test: $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) +student-test: + BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -v + load: $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..069984b4 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,125 @@ +name: grigoriev-lab2 + +x-app-env: &app-env + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + APP_ENV: ${APP_ENV:-lab} + APP_SHUTDOWN_TIMEOUT: ${APP_SHUTDOWN_TIMEOUT:-5} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60} + DB_POOL_MIN: ${DB_POOL_MIN:-1} + DB_POOL_MAX: ${DB_POOL_MAX:-10} + DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:-2} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL: ${CACHE_URL:-redis://valkey:6379/0} + +x-dns-opt: &dns-opt + - timeout:1 + - attempts:1 + +x-postgres: &postgres + image: postgres:17.11-alpine@sha256:266d3c257594e195b309ae9d1805e54c788f1d7b375f56bf6c367aac6c917e7b + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + command: ["postgres", "-c", "track_io_timing=on"] + secrets: [postgres_password] + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 12 + start_period: 10s + stop_grace_period: 30s + networks: [backend] + restart: unless-stopped + +services: + postgres: + <<: *postgres + volumes: + - pgdata:/var/lib/postgresql/data + + valkey: + image: valkey/valkey:8.1.11-alpine@sha256:2602ace2be6569bc2bbb06f873776516ab9089821525be34f4305c67eb9db02a + command: ["valkey-server", "--save", "", "--appendonly", "no", + "--maxmemory", "64mb", "--maxmemory-policy", "volatile-ttl"] + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 5s + timeout: 3s + retries: 12 + networks: [backend] + restart: unless-stopped + + migrate: + build: . + image: mtusi-messenger:lab2 + command: ["python", "src/migrate.py"] + environment: *app-env + secrets: [database_url] + depends_on: + postgres: + condition: service_healthy + networks: [backend] + restart: "no" + + api: + build: . + image: mtusi-messenger:lab2 + environment: *app-env + secrets: [database_url] + ports: + - "127.0.0.1:8080:8080" + depends_on: + migrate: + condition: service_completed_successfully + postgres: + condition: service_healthy + valkey: + condition: service_started + dns_opt: *dns-opt + stop_grace_period: 10s + networks: [frontend, backend] + restart: unless-stopped + + postgres-restore: + <<: *postgres + profiles: [restore] + volumes: + - pgdata_restore:/var/lib/postgresql/data + + api-restore: + image: mtusi-messenger:lab2 + profiles: [restore] + environment: + <<: *app-env + DATABASE_URL_FILE: /run/secrets/database_url_restore + CACHE_URL: "" + dns_opt: *dns-opt + secrets: [database_url_restore] + ports: + - "127.0.0.1:8081:8080" + depends_on: + postgres-restore: + condition: service_healthy + networks: [frontend, backend] + +volumes: + pgdata: + pgdata_restore: + +networks: + frontend: + backend: + internal: true + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + database_url_restore: + file: ./secrets/database_url_restore diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100644 index 00000000..6c0ce8ee --- /dev/null +++ b/scripts/init_secrets.py @@ -0,0 +1,28 @@ +import os +from pathlib import Path +import secrets + +ROOT = Path(__file__).resolve().parents[1] +SECRETS = ROOT / 'secrets' + + +def write(name, value): + path = SECRETS / name + if path.exists(): + print('keep existing secrets/%s' % name) + return path.read_text(encoding='utf-8').strip() + path.write_text(value + '\n', encoding='utf-8') + os.chmod(path, 0o644) + print('created secrets/%s' % name) + return value + + +def main(): + SECRETS.mkdir(exist_ok=True) + password = write('postgres_password', secrets.token_hex(24)) + write('database_url', 'postgresql://messenger:%s@postgres:5432/messenger' % password) + write('database_url_restore', 'postgresql://messenger:%s@postgres-restore:5432/messenger' % password) + + +if __name__ == '__main__': + main() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..713107fb --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,6 @@ +@echo off +cd /d "%~dp0.." +docker compose stop api || exit /b 1 +docker compose restart postgres valkey || exit /b 1 +docker compose up -d --no-build --no-recreate --wait postgres valkey || exit /b 1 +docker compose start api || exit /b 1 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..e269cef9 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,7 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose stop api +docker compose restart postgres valkey +docker compose up -d --no-build --no-recreate --wait postgres valkey +docker compose start api -- 2.54.0 From 0e5b76e558a707ede40bf4cf87c8cc87f30f1823 Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Thu, 29 Oct 2026 14:14:27 +0300 Subject: [PATCH 3/8] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B5=D0=B2=D0=B5=D1=81?= =?UTF-8?q?=D1=82=D0=B8=20=D1=81=D0=BE=D0=B1=D1=81=D1=82=D0=B2=D0=B5=D0=BD?= =?UTF-8?q?=D0=BD=D1=8B=D0=B5=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?= =?UTF-8?q?=D0=B0=20Bearer,=20=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20=D0=BF=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D0=BA=D0=B8=20?= =?UTF-8?q?=D1=83=D1=80=D0=BE=D0=B2=D0=BD=D1=8F=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- student-tests/expiry_check.py | 56 ++++++++++++ student-tests/failure_check.py | 83 +++++++++++++++++ student-tests/helpers.py | 101 +++++++++++++++++++++ student-tests/sigterm_check.py | 75 ++++++++++++++++ student-tests/test_api.py | 142 ++++++++++++++++++++++++++++++ student-tests/test_auth.py | 126 ++++++++++++++++++++++++++ student-tests/test_concurrency.py | 68 ++++++++++++++ student-tests/test_db.py | 58 ++++++++++++ 8 files changed, 709 insertions(+) create mode 100644 student-tests/expiry_check.py create mode 100644 student-tests/failure_check.py create mode 100644 student-tests/helpers.py create mode 100644 student-tests/sigterm_check.py create mode 100644 student-tests/test_api.py create mode 100644 student-tests/test_auth.py create mode 100644 student-tests/test_concurrency.py create mode 100644 student-tests/test_db.py diff --git a/student-tests/expiry_check.py b/student-tests/expiry_check.py new file mode 100644 index 00000000..7bde51ec --- /dev/null +++ b/student-tests/expiry_check.py @@ -0,0 +1,56 @@ +"""Usage (стенд уже запущен через docker compose up -d): + python student-tests/expiry_check.py --ttl 2 + +Скрипт пересоздаёт только api с SESSION_TTL_SECONDS=, проверяет истечение сессии, +затем возвращает api с обычным TTL из .env. Volumes и данные не трогаются. +""" +import argparse +import hashlib +import os +import time + +from helpers import call, compose, new_user, wait_ready + + +def restart_api(ttl=None): + env = dict(os.environ) + if ttl is None: + env.pop('SESSION_TTL_SECONDS', None) + else: + env['SESSION_TTL_SECONDS'] = str(ttl) + compose('up', '-d', '--no-deps', '--no-build', 'api', env=env) + wait_ready() + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--ttl', type=int, default=2) + args = parser.parse_args() + + print('пересоздаю api с SESSION_TTL_SECONDS=%d' % args.ttl) + restart_api(args.ttl) + try: + alice = new_user('expiry') + status = call('GET', '/api/v1/users/me', token=alice['token'])[0] + print('сразу после входа: /users/me -> %d' % status) + assert status == 200 + key = 'session:' + hashlib.sha256(alice['token'].encode()).hexdigest() + cache_ttl = int(compose('exec', '-T', 'valkey', 'valkey-cli', 'TTL', key)) + print('TTL ключа этой сессии в Valkey: %d с (-2 = ключа нет)' % cache_ttl) + assert cache_ttl <= args.ttl, 'кэш живёт дольше сессии' + + time.sleep(args.ttl + 1.5) + status, headers, _ = call('GET', '/api/v1/users/me', token=alice['token']) + print('через %.1f с: /users/me -> %d, WWW-Authenticate: %s' % (args.ttl + 1.5, status, headers['WWW-Authenticate'])) + assert status == 401 and headers['WWW-Authenticate'] == 'Bearer realm="messenger"' + status = call('DELETE', '/api/v1/auth/sessions/current', token=alice['token'])[0] + print('logout истёкшим токеном -> %d' % status) + assert status == 401 + print('PASS: сессия истекла по SESSION_TTL_SECONDS=%d, кэш не продлил её' % args.ttl) + finally: + print('возвращаю api с TTL из .env') + restart_api() + + +if __name__ == '__main__': + main() diff --git a/student-tests/failure_check.py b/student-tests/failure_check.py new file mode 100644 index 00000000..4c93d293 --- /dev/null +++ b/student-tests/failure_check.py @@ -0,0 +1,83 @@ +"""Usage (стенд уже запущен через docker compose up -d): + python student-tests/failure_check.py + +Останавливает Valkey, затем PostgreSQL (docker compose stop, без удаления volumes), +проверяет поведение API и восстановление после docker compose start. +""" +import time +import uuid + +from helpers import basic, call, compose, new_chat, new_user, wait_ready + +failures = [] + + +def timed(method, path, token=None, body=None, headers=None): + started = time.monotonic() + try: + status = call(method, path, body=body, token=token, headers=headers, timeout=10)[0] + except OSError as error: + status = type(error).__name__ + return status, time.monotonic() - started + + +def expect(title, result, allowed, max_seconds): + status, seconds = result + ok = status in allowed and seconds <= max_seconds + print(' %-48s -> %-4s за %.2f с %s' % (title, status, seconds, 'OK' if ok else 'FAIL')) + if not ok: + failures.append(title) + + +def main(): + alice = new_user('failure') + chat = new_chat(alice) + history = '/api/v1/chats/%s/messages' % chat['id'] + assert call('POST', history, {'text': 'до отказа'}, alice['token'])[0] == 201 + fake = uuid.uuid4().hex * 2 + + print('1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL') + compose('stop', 'valkey') + try: + expect('первый запрос: обнаружение отказа кэша', timed('GET', '/api/v1/users/me', alice['token']), [200], 1.5) + expect('GET /users/me действующим токеном', timed('GET', '/api/v1/users/me', alice['token']), [200], 1) + expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'без кэша'}), [201], 1) + expect('неизвестный токен', timed('GET', '/api/v1/users/me', fake), [401], 1) + expect('без Authorization', timed('GET', '/api/v1/users/me'), [401], 1) + expect('/health/ready (Valkey некритичен)', timed('GET', '/health/ready'), [200], 1) + started = time.monotonic() + other = new_user('nocache') + expect('регистрация и вход без кэша', (200, time.monotonic() - started), [200], 1) + expect('logout без кэша', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1) + expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1) + finally: + compose('up', '-d', '--wait', 'valkey') + + print('2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит') + compose('stop', 'postgres') + stopped_at = time.monotonic() + try: + expect('GET история', timed('GET', history, alice['token']), [503], 3) + expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'при отказе БД'}), [503], 3) + expect('неизвестный токен (не 200!)', timed('GET', '/api/v1/users/me', fake), [503], 3) + expect('без Authorization', timed('GET', '/api/v1/users/me'), [401], 1) + expect('вход по Basic верным паролем', timed('POST', '/api/v1/auth/sessions', + headers=basic(alice['username'], alice['password'])), [503], 3) + expect('/health/live', timed('GET', '/health/live'), [200], 1) + expect('/health/ready', timed('GET', '/health/ready'), [503], 3) + finally: + compose('up', '-d', '--wait', 'postgres') + ready_at = wait_ready() + print('3. PostgreSQL запущен: готовность через %.1f с после остановки' % (ready_at - stopped_at)) + status = call('GET', '/api/v1/users/me', token=alice['token'])[0] + texts = [m['text'] for m in call('GET', history + '?limit=100', token=alice['token'])[2]['items']] + print(' прежний токен -> %d; история: %s' % (status, texts)) + if status != 200 or texts != ['до отказа', 'без кэша']: + failures.append('восстановление') + + print('FAIL: ' + ', '.join(failures) if failures else 'PASS: отказы Valkey и PostgreSQL обработаны') + raise SystemExit(1 if failures else 0) + + +if __name__ == '__main__': + main() diff --git a/student-tests/helpers.py b/student-tests/helpers.py new file mode 100644 index 00000000..7654e210 --- /dev/null +++ b/student-tests/helpers.py @@ -0,0 +1,101 @@ +import base64 +import json +import os +from pathlib import Path +import subprocess +import time +import urllib.error +import urllib.parse +import urllib.request +import uuid + +BASE_URL = os.environ.get('BASE_URL', 'http://127.0.0.1:8080').rstrip('/') +ROOT = Path(__file__).resolve().parents[1] + + +def call(method, path, body=None, token=None, raw=None, headers=None, timeout=10): + all_headers = {} + if token: + all_headers['Authorization'] = 'Bearer ' + token + if body is not None: + raw = json.dumps(body, ensure_ascii=False).encode('utf-8') + if raw is not None: + all_headers['Content-Type'] = 'application/json' + all_headers.update(headers or {}) + request = urllib.request.Request(BASE_URL + path, data=raw, headers=all_headers, method=method) + try: + response = urllib.request.urlopen(request, timeout=timeout) + except urllib.error.HTTPError as error: + response = error + with response: + data = response.read() + return response.status, response.headers, json.loads(data) if data else None + + +def basic(username, password): + return {'Authorization': 'Basic ' + base64.b64encode((username + ':' + password).encode('utf-8')).decode()} + + +def register(label='user', password=None): + username = (label + '_' + uuid.uuid4().hex[:12])[:32] + password = password or 'Pw-' + uuid.uuid4().hex + status, _, user = call('POST', '/api/v1/users', {'username': username, 'display_name': label, 'password': password}) + assert status == 201, status + return user, password + + +def login(username, password): + status, _, session = call('POST', '/api/v1/auth/sessions', headers=basic(username, password)) + assert status == 201, status + return session + + +def new_user(label='user'): + user, password = register(label) + session = login(user['username'], password) + return dict(user, password=password, token=session['token']) + + +def new_chat(owner, *others, title='Тестовый чат'): + members = [owner['id']] + [u['id'] for u in others] + status, _, chat = call('POST', '/api/v1/chats', {'title': title, 'member_ids': members}, owner['token']) + assert status == 201, status + return chat + + +def read_all_messages(chat_id, token, limit): + items, cursor, pages = [], None, 0 + while True: + query = '?limit=%d' % limit + ('&cursor=' + urllib.parse.quote(cursor, safe='') if cursor else '') + status, _, page = call('GET', '/api/v1/chats/%s/messages%s' % (chat_id, query), token=token) + assert status == 200, status + items += page['items'] + pages += 1 + cursor = page['next_cursor'] + if cursor is None: + return items, pages + + +def compose(*args, env=None, check=True): + result = subprocess.run(['docker', 'compose', *args], cwd=ROOT, capture_output=True, text=True, + encoding='utf-8', env=env) + if check and result.returncode != 0: + raise RuntimeError('docker compose %s failed: %s' % (' '.join(args), result.stderr.strip())) + return result.stdout.strip() + + +def sql(query, db='messenger', service='postgres'): + return compose('exec', '-T', service, 'psql', '-U', 'messenger', '-d', db, '-X', '-tA', '-v', 'ON_ERROR_STOP=1', + '-c', query) + + +def wait_ready(seconds=90): + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + try: + if call('GET', '/health/ready', timeout=2)[0] == 200: + return time.monotonic() + except OSError: + pass + time.sleep(0.3) + raise AssertionError('API is not ready after %ds' % seconds) diff --git a/student-tests/sigterm_check.py b/student-tests/sigterm_check.py new file mode 100644 index 00000000..86f2ee5c --- /dev/null +++ b/student-tests/sigterm_check.py @@ -0,0 +1,75 @@ +"""Usage (стенд запущен через docker compose up -d): + python student-tests/sigterm_check.py + docker compose start api +""" +import argparse +import subprocess +import threading +import time +import urllib.error +import urllib.request +import uuid + +from helpers import BASE_URL, call, new_chat, new_user + + +def docker(*args): + return subprocess.run(['docker', *args], capture_output=True, text=True, encoding='utf-8').stdout.strip() + + +def probe_forever(results, stop_event): + while not stop_event.is_set(): + started = time.monotonic() + try: + with urllib.request.urlopen(BASE_URL + '/health/live', timeout=1) as response: + outcome = str(response.status) + except urllib.error.HTTPError as error: + outcome = str(error.code) + except Exception as error: + outcome = type(error).__name__ + results.append((started, outcome)) + time.sleep(0.02) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--container', default='grigoriev-lab2-api-1') + parser.add_argument('--stop-timeout', type=int, default=10, help='секунд до SIGKILL у docker stop') + args = parser.parse_args() + + marker = 'PRIVATE-' + uuid.uuid4().hex + alice = new_user('alice') + chat = new_chat(alice) + status = call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': marker}, alice['token'])[0] + logs_before = docker('logs', args.container) + print('сообщение с маркером отправлено: HTTP %d; маркер в логах: %s' % (status, marker in logs_before)) + + results, stop_event = [], threading.Event() + prober = threading.Thread(target=probe_forever, args=(results, stop_event)) + prober.start() + time.sleep(1) + + sigterm_at = time.monotonic() + docker('stop', '-t', str(args.stop_timeout), args.container) + stopped_at = time.monotonic() + time.sleep(1) + stop_event.set() + prober.join() + + before = [r for t, r in results if t < sigterm_at] + after = [r for t, r in results if t >= sigterm_at] + exit_code = docker('inspect', '--format', '{{.State.ExitCode}}', args.container) + print('docker stop занял: %.2f с (лимит %d с)' % (stopped_at - sigterm_at, args.stop_timeout)) + print('код выхода контейнера: %s (0 — сам завершился по SIGTERM; 137 — убит SIGKILL)' % exit_code) + print('запросы до SIGTERM: %d, все 200: %s' % (len(before), set(before) == {'200'})) + print('запросы после SIGTERM: %d, результаты: %s' % (len(after), sorted(set(after)))) + print('ответов 5xx за всё время: %d' % sum(r.startswith('5') for _, r in results)) + + print('\nлоги остановки:') + for line in docker('logs', args.container).splitlines(): + if any(word in line for word in ('Shutting down', 'stopping', 'shutdown', 'Finished server')): + print(' ' + line) + + +if __name__ == '__main__': + main() diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..502fbd65 --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,142 @@ +import unittest +import uuid + +from helpers import call, new_chat, new_user, read_all_messages + + +class ErrorFormatMixin: + def assertError(self, result, status, code): + actual, headers, body = result + self.assertEqual(actual, status) + self.assertEqual(body['error']['code'], code) + self.assertEqual(body['error']['request_id'], headers['X-Request-Id']) + self.assertNotIn('Traceback', body['error']['message']) + + +class InvalidJsonTest(ErrorFormatMixin, unittest.TestCase): + def test_malformed_json(self): + """Битый JSON -> 400 invalid_request""" + self.assertError(call('POST', '/api/v1/users', raw=b'{"username": "abc",'), 400, 'invalid_request') + + def test_json_not_object(self): + """JSON-массив вместо объекта -> 400""" + self.assertError(call('POST', '/api/v1/users', raw=b'[1, 2, 3]'), 400, 'invalid_request') + + def test_wrong_type(self): + """Число вместо строки -> 400 (без тихого приведения типов)""" + self.assertError(call('POST', '/api/v1/users', {'username': 12345, 'display_name': 'x', 'password': 'Long-enough-pass-1'}), 400, 'invalid_request') + + def test_extra_field(self): + """Лишнее поле в теле -> 400""" + body = {'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': 'x', 'password': 'Long-enough-pass-1', 'is_admin': True} + self.assertError(call('POST', '/api/v1/users', body), 400, 'invalid_request') + + +class DuplicateUsernameTest(ErrorFormatMixin, unittest.TestCase): + def test_duplicate_username(self): + """Повторная регистрация того же username -> 409 conflict""" + user = new_user('dup') + again = call('POST', '/api/v1/users', {'username': user['username'], 'display_name': 'Другой', + 'password': 'Other-password-123'}) + self.assertError(again, 409, 'conflict') + + +class ForeignChatTest(ErrorFormatMixin, unittest.TestCase): + def setUp(self): + self.alice, self.bob, self.eve = new_user('alice'), new_user('bob'), new_user('eve') + self.chat = new_chat(self.alice, self.bob) + self.path = '/api/v1/chats/' + self.chat['id'] + + def test_outsider_cannot_read_chat(self): + """Посторонний читает чат -> 404, как будто чата нет""" + self.assertError(call('GET', self.path, token=self.eve['token']), 404, 'not_found') + missing = call('GET', '/api/v1/chats/' + str(uuid.uuid4()), token=self.eve['token']) + self.assertEqual(missing[2]['error']['message'], call('GET', self.path, token=self.eve['token'])[2]['error']['message']) + + def test_outsider_cannot_write_or_read_history(self): + """Посторонний пишет/читает историю -> 404""" + self.assertError(call('POST', self.path + '/messages', {'text': 'чужое'}, self.eve['token']), 404, 'not_found') + self.assertError(call('GET', self.path + '/messages', token=self.eve['token']), 404, 'not_found') + + def test_outsider_does_not_see_chat_in_list(self): + """Чужой чат не попадает в список чатов""" + status, _, page = call('GET', '/api/v1/chats?limit=100', token=self.eve['token']) + self.assertEqual(status, 200) + self.assertNotIn(self.chat['id'], [c['id'] for c in page['items']]) + + def test_member_has_access(self): + """Участник видит чат (контроль: 404 выше не из-за ошибки в тесте)""" + self.assertEqual(call('GET', self.path, token=self.bob['token'])[0], 200) + + +class EmptyMessageTest(ErrorFormatMixin, unittest.TestCase): + def setUp(self): + self.alice = new_user('alice') + self.path = '/api/v1/chats/%s/messages' % new_chat(self.alice)['id'] + + def test_empty_text(self): + """Пустой текст -> 400""" + self.assertError(call('POST', self.path, {'text': ''}, self.alice['token']), 400, 'invalid_request') + + def test_whitespace_text(self): + """Текст только из пробельных символов -> 400""" + self.assertError(call('POST', self.path, {'text': ' \t\n '}, self.alice['token']), 400, 'invalid_request') + + def test_missing_text(self): + """Тело без поля text -> 400""" + self.assertError(call('POST', self.path, {}, self.alice['token']), 400, 'invalid_request') + + def test_text_length_limit(self): + """4000 символов можно (эмодзи = 1 символ), 4001 — 400""" + self.assertEqual(call('POST', self.path, {'text': '😀' * 4000}, self.alice['token'])[0], 201) + self.assertError(call('POST', self.path, {'text': 'x' * 4001}, self.alice['token']), 400, 'invalid_request') + + +class PaginationTest(ErrorFormatMixin, unittest.TestCase): + def setUp(self): + self.alice = new_user('alice') + self.chat = new_chat(self.alice) + self.sent = [call('POST', '/api/v1/chats/%s/messages' % self.chat['id'], + {'text': 'сообщение %d' % i}, self.alice['token'])[2] for i in range(7)] + + def test_walk_several_pages(self): + """7 сообщений по 3: три страницы, без потерь, повторов и перестановок""" + items, pages = read_all_messages(self.chat['id'], self.alice['token'], limit=3) + self.assertEqual(pages, 3) + self.assertEqual([m['id'] for m in items], [m['id'] for m in self.sent]) + keys = [(m['created_at'], m['id']) for m in items] + self.assertEqual(keys, sorted(keys)) + + def test_cursor_from_other_chat(self): + """cursor от другого чата -> 400""" + _, _, page = call('GET', '/api/v1/chats/%s/messages?limit=1' % self.chat['id'], token=self.alice['token']) + other = new_chat(self.alice, title='Другой') + self.assertError(call('GET', '/api/v1/chats/%s/messages?cursor=%s' % (other['id'], page['next_cursor']), + token=self.alice['token']), 400, 'invalid_request') + + def test_invalid_cursor_and_limit(self): + """Мусорный cursor и limit вне 1..100 -> 400""" + path = '/api/v1/chats/%s/messages' % self.chat['id'] + for query in ('?cursor=not-a-cursor', '?limit=0', '?limit=101', '?limit=abc'): + with self.subTest(query=query): + self.assertError(call('GET', path + query, token=self.alice['token']), 400, 'invalid_request') + + +class IdentityTest(ErrorFormatMixin, unittest.TestCase): + def test_sender_cannot_be_forged(self): + """sender_id в теле запрещён: отправитель только из сессии""" + alice, bob = new_user('alice'), new_user('bob') + chat = new_chat(alice, bob) + forged = call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': 'hi', 'sender_id': bob['id']}, alice['token']) + self.assertError(forged, 400, 'invalid_request') + + def test_nul_character_is_rejected(self): + """Символ NUL нельзя сохранить в PostgreSQL text -> 400, а не 500""" + alice = new_user('alice') + chat = new_chat(alice) + self.assertError(call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': 'a\u0000b'}, alice['token']), + 400, 'invalid_request') + + +if __name__ == '__main__': + unittest.main() diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 00000000..6d339b3c --- /dev/null +++ b/student-tests/test_auth.py @@ -0,0 +1,126 @@ +from datetime import datetime, timezone +import unittest +import uuid + +from helpers import basic, call, login, new_user, register + + +class RegistrationTest(unittest.TestCase): + def body(self, password): + return {'username': 'reg_' + uuid.uuid4().hex[:12], 'display_name': 'Регистрация', 'password': password} + + def test_password_is_not_returned(self): + """Ответ регистрации и /users/me не содержат password/hash""" + status, _, user = call('POST', '/api/v1/users', self.body('Secret-password-1')) + self.assertEqual(status, 201) + self.assertEqual(set(user), {'id', 'username', 'display_name', 'created_at'}) + + def test_password_length_limits(self): + """Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом""" + self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 11))[0], 400) + self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 129))[0], 400) + self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 128))[0], 201) + self.assertEqual(call('POST', '/api/v1/users', self.body('🔑' * 12))[0], 201) + + def test_password_required_and_not_blank(self): + """Без password или из одних пробелов -> 400""" + body = self.body('x') + del body['password'] + self.assertEqual(call('POST', '/api/v1/users', body)[0], 400) + self.assertEqual(call('POST', '/api/v1/users', self.body(' ' * 20))[0], 400) + + +class LoginTest(unittest.TestCase): + def setUp(self): + self.user, self.password = register('login') + + def assertBasicChallenge(self, result): + status, headers, body = result + self.assertEqual(status, 401) + self.assertEqual(headers['WWW-Authenticate'], 'Basic realm="messenger", charset="UTF-8"') + self.assertEqual(body['error']['code'], 'unauthorized') + return body['error']['message'] + + def test_login_returns_opaque_session(self): + """Вход: 201, token_type=Bearer, токен случайный и не содержит username/UUID""" + first = login(self.user['username'], self.password) + second = login(self.user['username'], self.password) + self.assertEqual(first['token_type'], 'Bearer') + self.assertEqual(first['user'], self.user) + self.assertGreaterEqual(len(first['token']), 43) + self.assertNotEqual(first['token'], second['token']) + self.assertNotIn(self.user['username'], first['token']) + self.assertNotIn(self.user['id'], first['token']) + expires = datetime.fromisoformat(first['expires_at'].replace('Z', '+00:00')) + self.assertGreater(expires, datetime.now(timezone.utc)) + + def test_wrong_password_and_unknown_user_look_the_same(self): + """Неверный пароль и несуществующий пользователь -> одинаковый 401 с Basic challenge""" + wrong = self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions', + headers=basic(self.user['username'], 'Wrong-password-1'))) + unknown = self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions', + headers=basic('nobody_' + uuid.uuid4().hex[:8], 'Wrong-password-1'))) + self.assertEqual(wrong, unknown) + + def test_malformed_basic(self): + """Нет заголовка, не base64, нет двоеточия, Bearer вместо Basic -> 401 Basic""" + for header in (None, 'Basic', 'Basic !!!not-base64!!!', 'Basic ' + 'bm9jb2xvbg==', 'Bearer abc'): + with self.subTest(header=header): + headers = {'Authorization': header} if header else {} + self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions', headers=headers)) + + def test_password_with_colon_and_unicode(self): + """Двоеточие и не-ASCII в пароле допустимы: делим только по первому ':'""" + user, password = register('colon', password='пароль:с:двоеточием🔑') + self.assertEqual(login(user['username'], password)['user']['id'], user['id']) + + def test_login_rejects_body(self): + """POST /auth/sessions принимает только заголовок, JSON body -> 400""" + status = call('POST', '/api/v1/auth/sessions', {'username': self.user['username']}, + headers=basic(self.user['username'], self.password))[0] + self.assertEqual(status, 400) + + +class BearerTest(unittest.TestCase): + def setUp(self): + self.alice = new_user('alice') + self.eve = new_user('eve') + + def assertBearerChallenge(self, headers): + status, response_headers, _ = call('GET', '/api/v1/users/me', headers=headers) + self.assertEqual(status, 401) + self.assertEqual(response_headers['WWW-Authenticate'], 'Bearer realm="messenger"') + + def test_only_bearer_is_accepted(self): + """Нет заголовка, Basic, X-User-Id, мусорный токен -> 401 Bearer""" + self.assertBearerChallenge({}) + self.assertBearerChallenge(basic(self.alice['username'], self.alice['password'])) + self.assertBearerChallenge({'X-User-Id': self.alice['id']}) + self.assertBearerChallenge({'Authorization': 'Bearer ' + uuid.uuid4().hex}) + self.assertBearerChallenge({'Authorization': 'Bearer'}) + + def test_scheme_is_case_insensitive(self): + """Схема аутентификации нечувствительна к регистру (RFC 9110)""" + status, _, me = call('GET', '/api/v1/users/me', headers={'Authorization': 'bearer ' + self.alice['token']}) + self.assertEqual((status, me['id']), (200, self.alice['id'])) + + def test_x_user_id_does_not_override_session(self): + """X-User-Id игнорируется: владелец определяется только токеном""" + status, _, me = call('GET', '/api/v1/users/me', token=self.alice['token'], headers={'X-User-Id': self.eve['id']}) + self.assertEqual((status, me['id']), (200, self.alice['id'])) + + +class LogoutTest(unittest.TestCase): + def test_logout_revokes_only_current_session(self): + """Logout -> 204 без тела; этот токен -> 401, вторая сессия того же пользователя работает""" + alice = new_user('alice') + other = login(alice['username'], alice['password'])['token'] + status, _, body = call('DELETE', '/api/v1/auth/sessions/current', token=alice['token']) + self.assertEqual((status, body), (204, None)) + self.assertEqual(call('GET', '/api/v1/users/me', token=alice['token'])[0], 401) + self.assertEqual(call('DELETE', '/api/v1/auth/sessions/current', token=alice['token'])[0], 401) + self.assertEqual(call('GET', '/api/v1/users/me', token=other)[0], 200) + + +if __name__ == '__main__': + unittest.main() diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 00000000..4d258446 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -0,0 +1,68 @@ +from concurrent.futures import ThreadPoolExecutor +import threading +import unittest +import uuid + +from helpers import basic, call, new_chat, new_user, read_all_messages + +CLIENTS = 10 +REGISTRATIONS = 20 +PER_CLIENT = 10 + + +class ConcurrencyTest(unittest.TestCase): + def test_100_messages_from_10_clients(self): + """100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории""" + users = [new_user('client%d' % i) for i in range(CLIENTS)] + chat = new_chat(users[0], *users[1:], title='Нагрузка') + path = '/api/v1/chats/%s/messages' % chat['id'] + barrier = threading.Barrier(CLIENTS) + + def client(index): + barrier.wait() + results = [] + for n in range(PER_CLIENT): + status, _, message = call('POST', path, {'text': 'client %d msg %d' % (index, n)}, users[index]['token']) + results.append((status, message)) + return results + + with ThreadPoolExecutor(max_workers=CLIENTS) as pool: + responses = [r for batch in pool.map(client, range(CLIENTS)) for r in batch] + + self.assertEqual([s for s, _ in responses], [201] * CLIENTS * PER_CLIENT) + sent_ids = {m['id'] for _, m in responses} + items, pages = read_all_messages(chat['id'], users[0]['token'], limit=30) + read_ids = [m['id'] for m in items] + keys = [(m['created_at'], m['id']) for m in items] + + self.assertEqual(len(sent_ids), 100, 'сервер выдал повторяющиеся id') + self.assertEqual(len(read_ids), 100, 'в истории не ровно 100 сообщений') + self.assertEqual(set(read_ids), sent_ids, 'история не совпадает с подтверждёнными сообщениями') + self.assertEqual(len({m['text'] for m in items}), 100, 'потерялся или задвоился текст') + self.assertEqual(keys, sorted(keys), 'история не упорядочена по (created_at, id)') + print('\n отправлено 201: %d, уникальных id: %d, прочитано: %d за %d страниц(ы)' + % (len(responses), len(sent_ids), len(read_ids), pages)) + + def test_parallel_registration_of_same_username(self): + """20 одновременных регистраций одного username -> ровно один 201, остальные 409; вход только с паролем победителя""" + username = 'race_' + uuid.uuid4().hex[:12] + barrier = threading.Barrier(REGISTRATIONS) + + def register(index): + password = 'Race-password-%02d' % index + barrier.wait() + status = call('POST', '/api/v1/users', {'username': username, 'display_name': 'Гонка', 'password': password})[0] + return status, password + + with ThreadPoolExecutor(max_workers=REGISTRATIONS) as pool: + results = list(pool.map(register, range(REGISTRATIONS))) + statuses = sorted(status for status, _ in results) + self.assertEqual(statuses, [201] + [409] * (REGISTRATIONS - 1)) + winner = [password for status, password in results if status == 201][0] + loser = [password for status, password in results if status == 409][0] + self.assertEqual(call('POST', '/api/v1/auth/sessions', headers=basic(username, winner))[0], 201) + self.assertEqual(call('POST', '/api/v1/auth/sessions', headers=basic(username, loser))[0], 401) + + +if __name__ == '__main__': + unittest.main() diff --git a/student-tests/test_db.py b/student-tests/test_db.py new file mode 100644 index 00000000..5997fd83 --- /dev/null +++ b/student-tests/test_db.py @@ -0,0 +1,58 @@ +import hashlib +import time +import unittest +import uuid + +from helpers import call, compose, new_chat, new_user, sql + + +class DatabaseTest(unittest.TestCase): + def test_chat_creation_is_rolled_back(self): + """Неизвестный участник: INSERT chats выполнен, INSERT chat_members упал по FK, всё откатано""" + alice = new_user('alice') + chats_before = int(sql('SELECT count(*) FROM chats')) + members_before = int(sql('SELECT count(*) FROM chat_members')) + ghost = str(uuid.uuid4()) + since = sql("SELECT to_char(now() - interval '1 second', 'YYYY-MM-DD\"T\"HH24:MI:SS\"Z\"')") + status, _, body = call('POST', '/api/v1/chats', {'title': 'Откат', 'member_ids': [alice['id'], ghost]}, + alice['token']) + self.assertEqual(status, 400, body) + time.sleep(0.5) + log = compose('logs', '--no-log-prefix', '--since', since, 'postgres') + self.assertIn('violates foreign key constraint', log) + self.assertIn(ghost, log) + self.assertEqual(int(sql('SELECT count(*) FROM chats')), chats_before) + self.assertEqual(int(sql('SELECT count(*) FROM chat_members')), members_before) + + def test_secrets_are_not_stored_in_plaintext(self): + """В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен""" + alice = new_user('alice') + password_hash = sql("SELECT password_hash FROM users WHERE id = '%s'" % alice['id']) + self.assertTrue(password_hash.startswith('$argon2id$'), password_hash[:10]) + self.assertNotIn(alice['password'], password_hash) + digest = hashlib.sha256(alice['token'].encode()).hexdigest() + self.assertEqual(sql("SELECT count(*) FROM sessions WHERE token_hash = '\\x%s'" % digest), '1') + dump = sql("SELECT string_agg(encode(token_hash, 'escape'), '') FROM sessions WHERE user_id = '%s'" % alice['id']) + self.assertNotIn(alice['token'], dump) + + def test_migrations_are_idempotent(self): + """Повторный запуск миграций ничего не меняет и завершается успешно""" + before = sql('SELECT version, applied_at FROM schema_migrations ORDER BY version') + users = sql('SELECT count(*) FROM users') + output = compose('run', '--rm', '--no-deps', 'migrate') + self.assertIn('skip 0001_init: already applied', output) + self.assertEqual(sql('SELECT version, applied_at FROM schema_migrations ORDER BY version'), before) + self.assertEqual(sql('SELECT count(*) FROM users'), users) + + def test_history_query_uses_index(self): + """Запрос страницы истории идёт по индексу (chat_id, created_at, id), без Sort""" + alice = new_user('alice') + chat = new_chat(alice) + plan = sql("SET enable_seqscan = off; SET enable_bitmapscan = off; EXPLAIN SELECT id FROM messages WHERE chat_id = '%s' " + "ORDER BY created_at, id LIMIT 51" % chat['id']) + self.assertIn('messages_chat_history_idx', plan) + self.assertNotIn('Sort', plan) + + +if __name__ == '__main__': + unittest.main() -- 2.54.0 From c8d078390c18214c1ba44e9ce8902ab425d348be Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Thu, 29 Oct 2026 14:14:28 +0300 Subject: [PATCH 4/8] =?UTF-8?q?=D0=98=D1=81=D1=81=D0=BB=D0=B5=D0=B4=D0=BE?= =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D0=B5=20=D1=82=D1=80=D0=B5=D0=BA=D0=B0?= =?UTF-8?q?=202,=20=D0=B4=D0=BE=D0=BA=D0=B0=D0=B7=D0=B0=D1=82=D0=B5=D0=BB?= =?UTF-8?q?=D1=8C=D1=81=D1=82=D0=B2=D0=B0=20=D0=B8=20=D0=BE=D1=82=D1=87?= =?UTF-8?q?=D1=91=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/app.yml | 26 + REPORT.md | 200 +++++- evidence/README.md | 14 + evidence/expiry.txt | 10 + evidence/explain-history.txt | 65 ++ evidence/failure.txt | 24 + evidence/load.json | 17 + evidence/persistence.txt | 39 ++ evidence/sigterm.txt | 16 + evidence/smoke.txt | 4 + evidence/student-tests.txt | 82 +++ .../track2/planner_random_page_cost_1_1.json | 29 + .../track2/planner_random_page_cost_4.json | 29 + evidence/track2/reads.json | 578 ++++++++++++++++++ evidence/track2/restore.json | 52 ++ evidence/track2/results.md | 111 ++++ evidence/track2/writes.json | 386 ++++++++++++ research/seed.sql | 62 ++ research/track2.py | 397 ++++++++++++ 19 files changed, 2126 insertions(+), 15 deletions(-) create mode 100644 .github/workflows/app.yml create mode 100644 evidence/expiry.txt create mode 100644 evidence/explain-history.txt create mode 100644 evidence/failure.txt create mode 100644 evidence/load.json create mode 100644 evidence/persistence.txt create mode 100644 evidence/sigterm.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/student-tests.txt create mode 100644 evidence/track2/planner_random_page_cost_1_1.json create mode 100644 evidence/track2/planner_random_page_cost_4.json create mode 100644 evidence/track2/reads.json create mode 100644 evidence/track2/restore.json create mode 100644 evidence/track2/results.md create mode 100644 evidence/track2/writes.json create mode 100644 research/seed.sql create mode 100644 research/track2.py diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml new file mode 100644 index 00000000..2338c371 --- /dev/null +++ b/.github/workflows/app.yml @@ -0,0 +1,26 @@ +name: Application +on: [push, pull_request] +permissions: + contents: read +jobs: + stack: + runs-on: ubuntu-latest + timeout-minutes: 20 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - run: cp .env.example .env + - run: python scripts/init_secrets.py + - run: docker compose config --quiet + - run: docker compose up -d --build --wait + - run: make test BASE_URL=http://127.0.0.1:8080 PYTHON=python + - run: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080 PYTHON=python + - run: make student-test BASE_URL=http://127.0.0.1:8080 PYTHON=python + - run: python student-tests/expiry_check.py --ttl 2 + - run: python student-tests/failure_check.py + - if: failure() + run: docker compose ps -a && docker compose logs --no-color + - if: always() + run: docker compose down -v diff --git a/REPORT.md b/REPORT.md index e42f2b05..22e4ac1b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,207 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Григорьев Павел, БПИ2302 +- Целевая оценка; выбранный трек 5, если нужен: 5, трек 2 «План запроса и восстановление» +- Commit/PR: ветка `solution/bpi2302-grigoriev`; ссылка на PR — после публикации +- Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.3.6 + psycopg-pool 3.3.3, argon2-cffi 25.1.0, redis-py 8.1.0 (полный список — `requirements.txt`); PostgreSQL 17.11, Valkey 8.1.11; документация PostgreSQL (transactions, EXPLAIN, pg_dump), Valkey (persistence, eviction), RFC 7617, RFC 6750, RFC 9106, OWASP Password Storage Cheat Sheet. При разработке использовался ИИ-ассистент. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Требования: Docker Engine 27.x с Compose v2 (проверено: Docker Desktop, Engine 27.2.0, WSL2 на Windows 10); Python 3.9+ только для тестов и скриптов (стандартная библиотека). `make` необязателен — ниже прямые команды. + +Образы закреплены тегом и digest: `python:3.12.15-slim-trixie@sha256:a6e34c59…`, `postgres:17.11-alpine@sha256:266d3c25…`, `valkey/valkey:8.1.11-alpine@sha256:2602ace2…`. Зависимости Python — `==` для всех пакетов, включая транзитивные. + +```sh +git clone mtusi2026lab2 && cd mtusi2026lab2 +git switch solution/bpi2302-grigoriev +cp .env.example .env # несекретная конфигурация +python scripts/init_secrets.py # secrets/postgres_password, database_url, database_url_restore (вне Git) +docker compose config --quiet +docker compose up -d --build --wait # postgres, valkey → migrate (exit 0) → api healthy +docker compose ps -a + +python tests/smoke.py --base-url http://127.0.0.1:8080 # make test +python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080 +# на Windows: --action-script scripts/restart.cmd (Python на Windows не исполняет .sh) +python -m unittest discover -s student-tests -v # make student-test +python student-tests/expiry_check.py --ttl 2 +python student-tests/failure_check.py +``` + +Bootstrap/миграции: одноразовый сервис `migrate` применяет `migrations/*.sql` по порядку под `pg_advisory_lock`, записывая версии в `schema_migrations`; API стартует только после его успешного завершения. Повтор безопасен: `docker compose run --rm migrate` → `skip 0001_init: already applied`. + +На Windows используйте `127.0.0.1`, а не `localhost`: Docker Desktop не слушает `::1`, и каждый запрос к `localhost` ждёт ~2 с перед переходом на IPv4. + +Остановка без потери данных: `docker compose stop` (или `docker compose down` — контейнеры удаляются, volume `pgdata` остаётся). **Намеренное удаление учебных данных:** `docker compose --profile restore down -v` (удаляет `grigoriev-lab2_pgdata` и `grigoriev-lab2_pgdata_restore`). Только данные эксперимента трека 2: `docker compose exec postgres psql -U messenger -c "DROP DATABASE bench"`; дампы — каталог `backups/` (в `.gitignore`). ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +клиент ──HTTP 127.0.0.1:8080──► api (uvicorn + FastAPI, stateless) + │ пул psycopg (1..10, wait 2 s, statement_timeout 5 s) + ├──────────► postgres:17 — источник истины: users, chats, chat_members, messages, sessions + │ volume pgdata + └──────────► valkey:8 — кэш проверки сессии (TTL ≤ 60 s), persistence выключена +migrate (one-shot) ──► postgres сеть backend: internal, порты БД/кэша не публикуются +``` + +| Роль | Service | Версия/digest | Health/readiness | Volume | Сеть/порт | Credentials | +| --- | --- | --- | --- | --- | --- | --- | +| api | `api` | сборка из `Dockerfile` | `GET /health/ready` (проверяет PostgreSQL) | — | frontend+backend, `127.0.0.1:8080` | secret `database_url` | +| миграции | `migrate` | тот же образ | exit 0 | — | backend | secret `database_url` | +| postgres | `postgres` | 17.11-alpine@sha256:266d… | `pg_isready` | `pgdata` | backend | `POSTGRES_PASSWORD_FILE` (secret) | +| redis_or_valkey | `valkey` | 8.1.11-alpine@sha256:2602… | `valkey-cli ping` | — (кэш) | backend | нет: только внутренняя сеть (учебное упрощение, hardening в lab7) | +| эксперимент restore | `postgres-restore`, `api-restore` (profile `restore`) | те же | те же | `pgdata_restore` | backend, `127.0.0.1:8081` | secret `database_url_restore` | + +**Источник истины** — PostgreSQL. Схема (`migrations/0001_init.sql`): + +| Таблица | Ключи и ограничения | Индексы под запросы | +| --- | --- | --- | +| `users` | PK id; `username` UNIQUE + CHECK `^[a-z0-9_]{3,32}$`; длина display_name; `password_hash` (Argon2id) | UNIQUE(username) — вход и гонка регистрации | +| `chats` | PK id; `created_by` FK → users | — | +| `chat_members` | PK (chat_id, user_id); FK → chats, users; `position` (порядок member_ids), UNIQUE(chat_id, position) | PK — проверка членства; `(user_id, chat_id)` — список чатов | +| `messages` | PK id; FK (chat_id, sender_id) → chat_members (отправитель — участник); длина text 1–4000 | `(chat_id, created_at, id)` — история keyset | +| `sessions` | PK `token_hash` (sha256, 32 байта); FK user_id; `expires_at > created_at` | `(user_id)`, `(expires_at)` | + +`id` и `created_at` назначает БД (`gen_random_uuid()`, `clock_timestamp()`), сессия БД в UTC. + +**Транзакционные границы.** Регистрация — один INSERT, гонку решает UNIQUE (`unique_violation` → 409). Вход — удаление истёкших сессий пользователя и вставка новой в одной транзакции. **Создание чата** — `INSERT chats` и `INSERT chat_members … FROM unnest(...) WITH ORDINALITY` в одной явной транзакции; неизвестный участник вызывает `foreign_key_violation`, откатывается всё (→ 400). Сообщение — один `INSERT … SELECT … WHERE EXISTS(членство)`, проверка доступа и запись атомарны. Чтение истории — проверка членства и keyset-SELECT на одном соединении. Все запросы параметризованы. + +**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Logout удаляет строку сессии (204), повтор — 401. + +**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside). TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. Инвалидация: logout удаляет строку в PostgreSQL, затем `DEL` в Valkey. Известное окно: гонка «чтение сессии из БД ↔ logout» может вернуть отозванную запись в кэш не дольше 60 с. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. + +**Readiness.** Критична только PostgreSQL (`SELECT 1` из пула за ≤ 1 с); Valkey некритичен. Отказ БД: `OperationalError`/`PoolTimeout` → 503 `unavailable` за ≤ ~2 с; запрос без проверенной сессии никогда не получает 200. + +**Перенесено из lab1:** middleware `X-Request-Id`, формат ошибок, pydantic-модели (strict, extra forbid), формат cursor, Dockerfile (non-root, healthcheck, exec CMD), student-tests (переведены на Bearer). **Изменено:** хранилище in-memory → PostgreSQL, `X-User-Id` → Basic/Bearer, `CreateUser.password`, keyset теперь в SQL, монотонные метки времени процесса заменены временем БД (порядок задаёт `(created_at, id)`). + +Соответствие `.env.example`: + +| Переменная | Где используется | По умолчанию | +| --- | --- | --- | +| `APP_HOST`, `APP_PORT` | uvicorn в контейнере | `0.0.0.0`, `8080` | +| `APP_ENV` | лог старта | `lab` | +| `APP_SHUTDOWN_TIMEOUT` | graceful shutdown uvicorn | `5` | +| `SESSION_TTL_SECONDS` | срок сессии | `3600` | +| `DATABASE_URL_FILE` | файл secret с DSN | `/run/secrets/database_url` | +| `CACHE_URL` | адрес Valkey (пусто — кэш выключен) | `redis://valkey:6379/0` | +| `SESSION_CACHE_TTL_SECONDS` | верхняя граница TTL кэша | `60` | +| `DB_POOL_MIN`, `DB_POOL_MAX`, `DB_POOL_TIMEOUT_SECONDS`, `DB_STATEMENT_TIMEOUT_MS` | пул и таймауты | `1`, `10`, `2`, `5000` | + +`SESSION_STORE` из skeleton не используется: сессии всегда в PostgreSQL. ## Доказательства критериев +Все файлы — `evidence/`, получены 2026-10-29 на стенде из раздела «Эксперименты». + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `python tests/smoke.py` (`make test`) | `PASS: lab2 public API scenario` | `smoke.txt` | +| 3: данные и сессии переживают рестарт API и хранилищ без удаления volumes | `tests/resilience.py --mode persistence` с `scripts/restart.cmd` (= `restart.sh`) | PASS; `ps` до/после: postgres, valkey, api перезапущены; в логах `database system is shut down` → `ready to accept connections`; volumes на месте | `persistence.txt` | +| 3: PostgreSQL с PK/FK, UNIQUE username, миграции с нуля и повторно без дублей | `migrations/0001_init.sql`; `test_migrations_are_idempotent` | повторный `migrate` → `skip … already applied`, `schema_migrations` и данные не изменились | `student-tests.txt` | +| 3: создание чата атомарно | `test_chat_creation_is_rolled_back` | в логе PostgreSQL FK-ошибка с UUID несуществующего участника, количество строк chats/chat_members не изменилось | `student-tests.txt` | +| 3: Basic только на входе, Bearer на остальном, X-User-Id не даёт доступ, expiry и logout, KDF | `test_auth.py`, `test_db.py` | Basic/X-User-Id/мусор → 401 Bearer; X-User-Id не подменяет пользователя; logout → 204, повтор 401; `password_hash` начинается с `$argon2id$`, в sessions — sha256 токена | `student-tests.txt` | +| 3: secrets/volumes не в Git | `git status --ignored` | `.env`, `secrets/`, `backups/` игнорируются | `.gitignore` | +| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py` | TTL ключа сессии в Valkey ≤ TTL сессии | `expiry.txt` | +| 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/db.py` | `%s`-параметры везде; пул 1..10, wait 2 с, statement_timeout 5 с, connect 3 с | код | +| 4: гонка регистрации одного username | `test_parallel_registration_of_same_username` | 20 одновременных: 1×201 + 19×409; вход только с паролем победителя | `student-tests.txt` | +| 4: rollback составной операции | см. «создание чата атомарно» | — | `student-tests.txt` | +| 4: индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений, без полного scan | `python research/track2.py explain` | 200 000 сообщений; `Limit → Index Scan using messages_chat_history_idx`, без Sort; 9–13 буферов на первой и на 90%-й странице чата из 100 000 | `explain-history.txt` | +| 4: expiry при коротком SESSION_TTL_SECONDS | `python student-tests/expiry_check.py --ttl 2` | сразу 200, через 3,5 с 401 с Bearer challenge, logout истёкшим → 401 | `expiry.txt` | +| 4: logout, неверный пароль | `test_auth.py` | см. выше; неверный пароль и несуществующий логин — одинаковый 401 | `student-tests.txt` | +| 4: недоступность Redis/БД | `python student-tests/failure_check.py` | Valkey stop: всё 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с); PostgreSQL stop: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта тот же токен и данные | `failure.txt` | +| 4 (из lab1): SIGTERM | `student-tests/sigterm_check.py` | `docker stop` 0,57 с, exit 0, 5xx — 0 | `sigterm.txt` | +| 5, трек 2 | `python research/track2.py all` | см. следующий раздел | `track2/` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Стенд: Windows 10 Pro 19045, Docker Desktop (Engine 27.2.0, WSL2), VM Docker: 12 CPU, 1,9 GiB RAM; лимиты контейнерам не заданы; клиент на той же машине. PostgreSQL 17.11, `shared_buffers=128MB`, остальное по умолчанию, `track_io_timing=on`. + +Нагрузка (`python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json`, closed loop, POST в один чат, без прогрева): 9 296 успешных, 0 ошибок, **309 RPS**, p50 10,4 / p95 30,8 / p99 34,8 мс. После прогона: api 74 MiB, postgres 35 MiB, valkey 3,6 MiB. Генератор closed-loop (coordinated omission), клиент делит CPU с сервером — это не предел пропускной способности. + +### Трек 2. План запроса истории и восстановление + +**Гипотезы.** +1. Запрос страницы истории `WHERE chat_id = ? [AND (created_at, id) > cursor] ORDER BY created_at, id LIMIT 51` с индексом `(chat_id, created_at, id)` читает O(limit) страниц **независимо от размера чата и глубины страницы**. Индексы `(chat_id)` или `(created_at, id)` проигрывают на части чатов из-за неравномерности размеров. OFFSET растёт линейно с глубиной. +2. Составной индекс увеличивает стоимость записи заметно меньше, чем ускоряет чтение. +3. `pg_dump` даёт согласованный снимок на момент начала: восстановление в новое хранилище воспроизводит все данные до снимка (count и контрольные суммы), записи после начала дампа теряются (RPO = момент начала дампа). + +**Методика** (`research/track2.py`, `research/seed.sql`, повторяемо: `python research/track2.py all`). +- Отдельная БД `bench` со схемой из тех же миграций. 200 000 сообщений, `setseed(0.42)`: 1 чат × 100 000, 20 × 3 000, 4 000 × 10 (сильный перекос). Длина текста 20–400 символов, времена равномерно за 30 дней, вставка в порядке времени — физический порядок таблицы не совпадает с chat_id, как в реальной переписке. Таблица 96 MB. +- Варианты индекса истории: `pk_only`, `(chat_id)`, `(created_at, id)`, `(chat_id, created_at, id)` (рабочий). Перед каждым вариантом остальные индексы удаляются, затем `ANALYZE`. +- Запросы — точная форма из приложения, `LIMIT 51`: первая страница, keyset и OFFSET на глубине 50% и 90%, для большого, среднего и маленького чата. По 3 прогрева + 15 замеров `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)`, медиана и p95 времени, буферы, форма плана. +- Запись: (а) `EXPLAIN ANALYZE INSERT` 20 000 строк в транзакции с ROLLBACK после `CHECKPOINT`, медиана из 5 — время узла Insert (таблица + индексы), время FK-триггера, WAL на строку, без шума commit-fsync; (б) `pgbench` с одной вставкой на транзакцию, 4 клиента, 10 с × 5 повторов. +- Восстановление: пустой volume `pgdata_restore` → `pg_dump -Fc` БД `bench` и `messenger` **во время** параллельной записи pgbench (маркер `during dump`) → `docker compose cp` → `pg_restore -j 4` в `postgres-restore` → `ANALYZE` → сверка count и md5 (все сообщения по id, первая и 90%-я страница большого чата, весь маленький чат) → `api-restore` на восстановленной `messenger` с **прежним токеном**. + +**Результаты чтения** (медиана, мс; в скобках — буферы shared hit+read). Полностью — `evidence/track2/results.md`, `reads.json`. + +| запрос | pk_only | (chat_id) | (created_at, id) | **(chat_id, created_at, id)** | +| --- | --- | --- | --- | --- | +| большой чат, первая страница | 31,6 (12 361) | 29,1 (12 361) | 0,055 (9) | **0,057 (9)** | +| большой, keyset 90% | 25,1 (12 303) | 25,9 (12 303) | 0,057 (17) | **0,054 (11)** | +| большой, OFFSET 90% | 135,5 | 130,2 | 41,1 (17 650) | 132,1 (12 361) Seq Scan + Sort на диск | +| средний (3 000), keyset 90% | 23,4 | 3,4 (2 695) | 0,354 (314) | **0,057 (49)** | +| маленький (10), первая | 20,1 | 0,061 (13) | 21,7 (12 361) | **0,039 (13)** | +| маленький, keyset 50% | 22,9 | 0,064 | 24,4 (12 273) | **0,050 (8)** | + +- Рабочий индекс: все страницы всех чатов — 0,04–0,06 мс и 4–13 буферов, план `Limit → Index Scan`, без Sort. **Гипотеза 1 подтверждена.** +- `(chat_id)`: маленький чат быстро, но большой — Seq Scan (индекс невыгоден при 50% таблицы), средний — Bitmap + Sort всех 3 000 строк. +- `(created_at, id)`: идеален для большого чата (его сообщения — половина таблицы, первые 51 по времени находятся сразу), но для маленького чата пришлось бы пройти весь индекс до 10 нужных строк — планировщик выбирает Seq Scan (21,7 мс). Именно неравномерность размеров отличает эти варианты. +- OFFSET: даже с рабочим индексом на глубине 90 000 планировщик выбрал Parallel Seq Scan + внешнюю сортировку (15 MB на диск), 120–132 мс против 0,054 мс у keyset — в ~2 400 раз. Доп. замер (`planner_random_page_cost_*.json`): при `random_page_cost=1.1` (значение для SSD вместо HDD-значения 4) план становится Index Scan, 21,3 мс — всё равно в ~400 раз медленнее keyset и линейно растёт с глубиной. + +**Результаты записи** (`writes.json`): + +| вариант | INSERT, мс/1000 строк | FK-проверка, мс/1000 | WAL, байт/строку | размер индексов, MiB | pgbench TPS медиана [min..max] | +| --- | --- | --- | --- | --- | --- | +| pk_only | 9,80 | 31,3 | 2 793 | 0 | 784 [529..3 584] | +| (chat_id) | 11,24 | 30,1 | 2 951 | 1,5 | 3 541 [2 776..3 601] | +| (created_at, id) | 10,85 | 30,8 | 2 877 | 7,8 | 3 491 [3 477..3 522] | +| **(chat_id, created_at, id)** | **11,79** | 31,3 | **3 036** | 11,2 | 3 505 [2 774..3 540] | +| рабочий + (created_at, id) | 12,78 | 30,8 | 3 121 | ≈ 19 (11,2 + 7,8) | 3 553 [783..3 579] | + +- Рабочий индекс: +20% времени узла INSERT и +8,7% WAL на строку относительно таблицы без индексов истории, 11,2 MiB на 200 000 строк. Чтение страницы ускоряется в 400–2 400 раз. **Гипотеза 2 подтверждена.** +- Неожиданно: ~70% времени вставки — проверка составного FK `messages(chat_id, sender_id) → chat_members`, а не индексы. +- pgbench (commit на каждую строку) не различает варианты: пропускная способность упирается в fsync WAL виртуального диска Docker Desktop, у которого время `sync` при checkpoint скачет 0,01–1,7 с; отдельные прогоны падают до ~500–800 TPS в любом варианте (медиана `pk_only` — 3 таких прогона из 5). Вывод о стоимости индекса делаем по детерминированному пакетному замеру. + +**Результаты восстановления** (`restore.json`): + +| этап | с | +| --- | --- | +| `pg_dump -Fc bench` (200 000 сообщений, 13,4 MiB) | 1,69 | +| `pg_dump -Fc messenger` | 0,51 | +| копирование дампов через хост | 1,52 | +| `pg_restore -j 4` bench (данные + индексы + FK) | 2,36 | +| `pg_restore` messenger | 0,42 | +| `ANALYZE` | 0,74 | +| запуск и readiness `api-restore` | 6,74 | +| **RTO на этом стенде** | **≈ 14** | + +- Count всех таблиц и все md5 совпали (`mismatches: []`). `api-restore` на восстановленной БД: `GET /users/me` с **прежним** токеном → 200, история чата совпадает с исходной. +- Запись во время дампа: всего закоммичено 11 172 строки-маркера, в backup — 4 482 (закоммиченные до снимка; до старта `pg_dump` их было ≥ 3 787), **6 690 после начала снимка потеряны** при восстановлении из этого дампа. **Гипотеза 3 подтверждена:** RPO логического backup = момент начала `pg_dump`. + +**Обсуждение и ограничения.** +- Все замеры «тёплые» (данные в shared buffers/кэше ОС); холодный кэш на Docker Desktop честно не воспроизводится (кэш ОС VM не сбрасывается). Буферы и форма плана — основная метрика, миллисекунды — ориентир для этого ноутбука. +- Запросы с литералами; приложение через psycopg после 5 повторов использует prepared statements, и PostgreSQL может выбрать generic plan. Для рабочего индекса он тот же (Index Scan), для OFFSET/перекошенных данных может отличаться. +- `random_page_cost=4` оставлен по умолчанию; рекомендация для SSD — 1.1, но keyset от этого не зависит. +- RTO растёт примерно линейно с объёмом (restore + построение индексов): при 13 MiB дампа — секунды, на гигабайтах — минуты–часы; ускоряют `-j`, физический backup (`pg_basebackup`). RPO логического дампа = период между дампами; для секундного RPO нужен PITR (архив WAL + базовая копия) — не реализован. +- `pg_dump` одной БД не содержит роли/глобальные объекты (`pg_dumpall --globals-only`); у нас роль создаётся образом при init. +- Backup содержит хеши паролей и хеши действующих сессий — восстановленная копия принимает старые токены; дамп нужно хранить как секрет (`backups/` вне Git). +- Один Docker-host: нет защиты от потери хоста/диска, backup хранится на той же машине. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| restart api + postgres + valkey (`restart.sh`) | данные и прежний токен сохраняются | PASS, тот же токен | ≈ 10 с до ready; потерь нет | +| `docker compose stop valkey` | обход кэша, всё работает | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с | мгновенно; потерь нет | +| `docker compose stop postgres` | ограниченный 503, анонимный не проходит | 503 за ≈ 2 с, неизвестный токен 503, ready 503, live 200 | ready через 13,1 с после stop (включая ~10 с проверок во время отказа); потерь нет | +| SESSION_TTL_SECONDS=2 | истечение сессии | 401 через 3,5 с | — | +| SIGTERM api | корректная остановка | 0,57 с, exit 0 | — | +| backup → restore в новый volume | совпадение данных | count и md5 совпали, API со старым токеном | RTO ≈ 14 с; потеряны записи после начала дампа (6 690) | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Выдерживается: рестарт любого контейнера, отказ Valkey (деградация без ошибок), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа. +- Окно устаревания кэша сессий при гонке с logout — до 60 с (TTL); закрыть можно tombstone-ключом при logout. +- Valkey без пароля и TLS — допустимо только во внутренней сети учебного стенда; TLS для внешнего API появится в lab7, Basic по HTTP — только локально. +- Rate limiting входа (защита от перебора паролей) не реализован. +- Истёкшие сессии удаляются при следующем входе пользователя; фоновой чистки нет (индекс `expires_at` готов для неё). +- Для lab3: API stateless, сессии общие (PostgreSQL), миграции вынесены — готово к нескольким репликам; добавятся `Idempotency-Key` и `X-Instance-Id`. diff --git a/evidence/README.md b/evidence/README.md index 8df70015..b9059baa 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -3,3 +3,17 @@ Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. + +## Файлы этого решения (2026-10-29, Windows 10 + Docker Desktop 27.2.0, VM 12 CPU / 1,9 GiB) + +| Файл | Команда | Что показывает | +| --- | --- | --- | +| `smoke.txt` | `python tests/smoke.py --base-url http://127.0.0.1:8080` | публичный сценарий lab2 | +| `persistence.txt` | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | PASS + `docker compose ps` до/после, строки остановки/старта из логов, volumes | +| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 36 собственных тестов: API, аутентификация, гонки, rollback, миграции | +| `expiry.txt` | `python student-tests/expiry_check.py --ttl 2` | истечение сессии и TTL ключа в Valkey | +| `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey и PostgreSQL | +| `sigterm.txt` | `python student-tests/sigterm_check.py` | остановка API по SIGTERM | +| `load.json` | `python tests/load.py --duration 30 --concurrency 4` | базовая нагрузка | +| `explain-history.txt` | `python research/track2.py explain` | EXPLAIN (ANALYZE, BUFFERS) истории на 200 000 сообщений | +| `track2/*.json`, `track2/results.md` | `python research/track2.py all` | трек 2: чтение, запись, backup/restore | diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 00000000..91dc987f --- /dev/null +++ b/evidence/expiry.txt @@ -0,0 +1,10 @@ +# python student-tests/expiry_check.py --ttl 2 +# date: 2026-10-29T09:20:36Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM + +пересоздаю api с SESSION_TTL_SECONDS=2 +сразу после входа: /users/me -> 200 +TTL ключа этой сессии в Valkey: 1 с (-2 = ключа нет) +через 3.5 с: /users/me -> 401, WWW-Authenticate: Bearer realm="messenger" +logout истёкшим токеном -> 401 +PASS: сессия истекла по SESSION_TTL_SECONDS=2, кэш не продлил её +возвращаю api с TTL из .env diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt new file mode 100644 index 00000000..9bcc1060 --- /dev/null +++ b/evidence/explain-history.txt @@ -0,0 +1,65 @@ +# EXPLAIN (ANALYZE, BUFFERS): история сообщений, рабочий индекс messages_chat_history_idx +# {"date": "2026-10-29T09:19:19Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB"} +# messages: 200000; big chat: 100000, medium: 3000, small: 10 + +## big_first +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b' ORDER BY created_at, id LIMIT 51 +Limit (cost=0.42..27.46 rows=51 width=464) (actual time=0.034..0.056 rows=51 loops=1) + Buffers: shared hit=9 + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..53460.07 rows=100847 width=464) (actual time=0.034..0.052 rows=51 loops=1) + Index Cond: (chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b'::uuid) + Buffers: shared hit=9 +Planning: + Buffers: shared hit=140 +Planning Time: 1.713 ms +Execution Time: 0.106 ms + +## big_d90_keyset +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b' AND (created_at, id) > ('2026-09-28 00:28:21.157057+00', 'c0c9ed9c-be61-4384-8a45-bae9a536e6bf') ORDER BY created_at, id LIMIT 51 +Limit (cost=0.42..143.81 rows=51 width=464) (actual time=0.036..0.061 rows=51 loops=1) + Buffers: shared hit=11 + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..27913.79 rows=9928 width=464) (actual time=0.035..0.056 rows=51 loops=1) + Index Cond: ((chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b'::uuid) AND (ROW(created_at, id) > ROW('2026-09-28 00:28:21.157057+00'::timestamp with time zone, 'c0c9ed9c-be61-4384-8a45-bae9a536e6bf'::uuid))) + Buffers: shared hit=11 +Planning: + Buffers: shared hit=139 +Planning Time: 1.479 ms +Execution Time: 0.144 ms + +## big_d90_offset +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b' ORDER BY created_at, id OFFSET 90000 LIMIT 51 +Limit (cost=36460.92..36461.04 rows=1 width=464) (actual time=112.111..123.230 rows=51 loops=1) + Buffers: shared hit=12711, temp read=5508 written=5850 + I/O Timings: temp read=7.753 write=67.976 + -> Gather Merge (cost=26655.57..36460.92 rows=84040 width=464) (actual time=83.327..120.582 rows=90051 loops=1) + Workers Planned: 2 + Workers Launched: 2 + Buffers: shared hit=12711, temp read=5508 written=5850 + I/O Timings: temp read=7.753 write=67.976 + -> Sort (cost=25655.55..25760.60 rows=42020 width=464) (actual time=77.801..83.567 rows=30068 loops=3) + Sort Key: created_at, id + Sort Method: external merge Disk: 15832kB + Buffers: shared hit=12711, temp read=5508 written=5850 + I/O Timings: temp read=7.753 write=67.976 + Worker 0: Sort Method: external merge Disk: 16424kB + Worker 1: Sort Method: external merge Disk: 14416kB + -> Parallel Seq Scan on messages (cost=0.00..13664.67 rows=42020 width=464) (actual time=0.012..17.673 rows=33333 loops=3) + Filter: (chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b'::uuid) + Rows Removed by Filter: 33333 + Buffers: shared hit=12623 +Planning: + Buffers: shared hit=140 +Planning Time: 1.732 ms +Execution Time: 129.398 ms + +## small_first +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '60557307-b3a2-4910-b148-88898ec43ea1' ORDER BY created_at, id LIMIT 51 +Limit (cost=0.42..50.93 rows=12 width=464) (actual time=0.038..0.104 rows=10 loops=1) + Buffers: shared hit=13 + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..50.93 rows=12 width=464) (actual time=0.037..0.103 rows=10 loops=1) + Index Cond: (chat_id = '60557307-b3a2-4910-b148-88898ec43ea1'::uuid) + Buffers: shared hit=13 +Planning: + Buffers: shared hit=140 +Planning Time: 1.721 ms +Execution Time: 0.149 ms diff --git a/evidence/failure.txt b/evidence/failure.txt new file mode 100644 index 00000000..a2077384 --- /dev/null +++ b/evidence/failure.txt @@ -0,0 +1,24 @@ +# python student-tests/failure_check.py +# date: 2026-10-29T09:20:57Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM + +1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL + первый запрос: обнаружение отказа кэша -> 200 за 1.01 с OK + GET /users/me действующим токеном -> 200 за 0.00 с OK + POST сообщение -> 201 за 0.01 с OK + неизвестный токен -> 401 за 0.00 с OK + без Authorization -> 401 за 0.01 с OK + /health/ready (Valkey некритичен) -> 200 за 0.00 с OK + регистрация и вход без кэша -> 200 за 0.06 с OK + logout без кэша -> 204 за 0.01 с OK + отозванный токен -> 401 за 0.00 с OK +2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит + GET история -> 503 за 2.01 с OK + POST сообщение -> 503 за 2.00 с OK + неизвестный токен (не 200!) -> 503 за 2.00 с OK + без Authorization -> 401 за 0.03 с OK + вход по Basic верным паролем -> 503 за 2.01 с OK + /health/live -> 200 за 0.00 с OK + /health/ready -> 503 за 1.03 с OK +3. PostgreSQL запущен: готовность через 15.1 с после остановки + прежний токен -> 200; история: ['до отказа', 'без кэша'] +PASS: отказы Valkey и PostgreSQL обработаны diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 00000000..31e62f07 --- /dev/null +++ b/evidence/load.json @@ -0,0 +1,17 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.081, + "concurrency": 4, + "successful_requests": 9296, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 309.032, + "successful_latency_ms": { + "p50": 10.443, + "p95": 30.846, + "p99": 34.768 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..5e0f2e69 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,39 @@ +# persistence: python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8080 +# date: 2026-10-29T09:19:40Z; base commit: 65003b6 (working tree, solution uncommitted); host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM + +$ docker compose ps -a (before) +SERVICE STATUS +api Up 26 minutes (healthy) +api-restore Exited (0) 37 seconds ago +migrate Exited (0) 27 minutes ago +postgres Up 26 minutes (healthy) +postgres-restore Up About a minute (healthy) +valkey Up 26 minutes (healthy) + +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. + +$ docker compose ps -a (after) +SERVICE STATUS +api Up 1 second (health: starting) +api-restore Exited (0) 48 seconds ago +migrate Exited (0) 2 seconds ago +postgres Up 9 seconds (healthy) +postgres-restore Up About a minute (healthy) +valkey Up 9 seconds (healthy) + +$ docker compose logs --since 2026-10-29T09:19:40Z postgres valkey api | grep shutdown/ready lines +valkey-1 | 7:M 29 Oct 2026 09:19:42.428 * User requested shutdown... +valkey-1 | 7:M 29 Oct 2026 09:19:42.927 * Server initialized +valkey-1 | 7:M 29 Oct 2026 09:19:42.927 * Ready to accept connections tcp +api-1 | 2026-10-29 09:19:41,679 INFO messenger: application stopping +api-1 | 2026-10-29 09:19:51,290 INFO uvicorn.error: Waiting for application startup. +api-1 | 2026-10-29 09:19:51,293 INFO messenger: application started +postgres-1 | 2026-10-29 09:19:42.542 UTC [27] LOG: checkpoint complete: wrote 7023 buffers (42.9%); 0 WAL file(s) added, 0 removed, 5 recycled; write=0.118 s, +postgres-1 | 2026-10-29 09:19:42.592 UTC [1] LOG: database system is shut down +postgres-1 | 2026-10-29 09:19:43.092 UTC [29] LOG: database system was shut down at 2026-10-29 09:19:42 UTC +postgres-1 | 2026-10-29 09:19:43.101 UTC [1] LOG: database system is ready to accept connections + +$ docker volume ls (volumes kept) +grigoriev-lab2_pgdata +grigoriev-lab2_pgdata_restore diff --git a/evidence/sigterm.txt b/evidence/sigterm.txt new file mode 100644 index 00000000..222749d1 --- /dev/null +++ b/evidence/sigterm.txt @@ -0,0 +1,16 @@ +# python student-tests/sigterm_check.py; then docker compose start api +# date: 2026-10-29T09:21:28Z + +сообщение с маркером отправлено: HTTP 201; маркер в логах: False +docker stop занял: 0.57 с (лимит 10 с) +код выхода контейнера: 0 (0 — сам завершился по SIGTERM; 137 — убит SIGKILL) +запросы до SIGTERM: 30, все 200: True +запросы после SIGTERM: 24, результаты: ['200', 'RemoteDisconnected', 'URLError'] +ответов 5xx за всё время: 0 + +логи остановки: + 2026-10-29 09:21:29,562 INFO uvicorn.error: Shutting down + 2026-10-29 09:21:29,662 INFO uvicorn.error: Waiting for application shutdown. + 2026-10-29 09:21:29,662 INFO messenger: application stopping + 2026-10-29 09:21:29,663 INFO uvicorn.error: Application shutdown complete. + 2026-10-29 09:21:29,664 INFO uvicorn.error: Finished server process [1] diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..3dd84dc0 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,4 @@ +# python tests/smoke.py --base-url http://127.0.0.1:8080 +# date: 2026-10-29T09:19:39Z; base commit: 65003b6 (working tree, solution uncommitted); host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM + +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..4975ee26 --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,82 @@ +# python -m unittest discover -s student-tests -v +# date: 2026-10-29T09:20:03Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM + +test_duplicate_username (test_api.DuplicateUsernameTest.test_duplicate_username) +Повторная регистрация того же username -> 409 conflict ... ok +test_empty_text (test_api.EmptyMessageTest.test_empty_text) +Пустой текст -> 400 ... ok +test_missing_text (test_api.EmptyMessageTest.test_missing_text) +Тело без поля text -> 400 ... ok +test_text_length_limit (test_api.EmptyMessageTest.test_text_length_limit) +4000 символов можно (эмодзи = 1 символ), 4001 — 400 ... ok +test_whitespace_text (test_api.EmptyMessageTest.test_whitespace_text) +Текст только из пробельных символов -> 400 ... ok +test_member_has_access (test_api.ForeignChatTest.test_member_has_access) +Участник видит чат (контроль: 404 выше не из-за ошибки в тесте) ... ok +test_outsider_cannot_read_chat (test_api.ForeignChatTest.test_outsider_cannot_read_chat) +Посторонний читает чат -> 404, как будто чата нет ... ok +test_outsider_cannot_write_or_read_history (test_api.ForeignChatTest.test_outsider_cannot_write_or_read_history) +Посторонний пишет/читает историю -> 404 ... ok +test_outsider_does_not_see_chat_in_list (test_api.ForeignChatTest.test_outsider_does_not_see_chat_in_list) +Чужой чат не попадает в список чатов ... ok +test_nul_character_is_rejected (test_api.IdentityTest.test_nul_character_is_rejected) +Символ NUL нельзя сохранить в PostgreSQL text -> 400, а не 500 ... ok +test_sender_cannot_be_forged (test_api.IdentityTest.test_sender_cannot_be_forged) +sender_id в теле запрещён: отправитель только из сессии ... ok +test_extra_field (test_api.InvalidJsonTest.test_extra_field) +Лишнее поле в теле -> 400 ... ok +test_json_not_object (test_api.InvalidJsonTest.test_json_not_object) +JSON-массив вместо объекта -> 400 ... ok +test_malformed_json (test_api.InvalidJsonTest.test_malformed_json) +Битый JSON -> 400 invalid_request ... ok +test_wrong_type (test_api.InvalidJsonTest.test_wrong_type) +Число вместо строки -> 400 (без тихого приведения типов) ... ok +test_cursor_from_other_chat (test_api.PaginationTest.test_cursor_from_other_chat) +cursor от другого чата -> 400 ... ok +test_invalid_cursor_and_limit (test_api.PaginationTest.test_invalid_cursor_and_limit) +Мусорный cursor и limit вне 1..100 -> 400 ... ok +test_walk_several_pages (test_api.PaginationTest.test_walk_several_pages) +7 сообщений по 3: три страницы, без потерь, повторов и перестановок ... ok +test_only_bearer_is_accepted (test_auth.BearerTest.test_only_bearer_is_accepted) +Нет заголовка, Basic, X-User-Id, мусорный токен -> 401 Bearer ... ok +test_scheme_is_case_insensitive (test_auth.BearerTest.test_scheme_is_case_insensitive) +Схема аутентификации нечувствительна к регистру (RFC 9110) ... ok +test_x_user_id_does_not_override_session (test_auth.BearerTest.test_x_user_id_does_not_override_session) +X-User-Id игнорируется: владелец определяется только токеном ... ok +test_login_rejects_body (test_auth.LoginTest.test_login_rejects_body) +POST /auth/sessions принимает только заголовок, JSON body -> 400 ... ok +test_login_returns_opaque_session (test_auth.LoginTest.test_login_returns_opaque_session) +Вход: 201, token_type=Bearer, токен случайный и не содержит username/UUID ... ok +test_malformed_basic (test_auth.LoginTest.test_malformed_basic) +Нет заголовка, не base64, нет двоеточия, Bearer вместо Basic -> 401 Basic ... ok +test_password_with_colon_and_unicode (test_auth.LoginTest.test_password_with_colon_and_unicode) +Двоеточие и не-ASCII в пароле допустимы: делим только по первому ':' ... ok +test_wrong_password_and_unknown_user_look_the_same (test_auth.LoginTest.test_wrong_password_and_unknown_user_look_the_same) +Неверный пароль и несуществующий пользователь -> одинаковый 401 с Basic challenge ... ok +test_logout_revokes_only_current_session (test_auth.LogoutTest.test_logout_revokes_only_current_session) +Logout -> 204 без тела; этот токен -> 401, вторая сессия того же пользователя работает ... ok +test_password_is_not_returned (test_auth.RegistrationTest.test_password_is_not_returned) +Ответ регистрации и /users/me не содержат password/hash ... ok +test_password_length_limits (test_auth.RegistrationTest.test_password_length_limits) +Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом ... ok +test_password_required_and_not_blank (test_auth.RegistrationTest.test_password_required_and_not_blank) +Без password или из одних пробелов -> 400 ... ok +test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients) +100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории ... ok +test_parallel_registration_of_same_username (test_concurrency.ConcurrencyTest.test_parallel_registration_of_same_username) +20 одновременных регистраций одного username -> ровно один 201, остальные 409; вход только с паролем победителя ... ok +test_chat_creation_is_rolled_back (test_db.DatabaseTest.test_chat_creation_is_rolled_back) +Неизвестный участник: INSERT chats выполнен, INSERT chat_members упал по FK, всё откатано ... ok +test_history_query_uses_index (test_db.DatabaseTest.test_history_query_uses_index) +Запрос страницы истории идёт по индексу (chat_id, created_at, id), без Sort ... ok +test_migrations_are_idempotent (test_db.DatabaseTest.test_migrations_are_idempotent) +Повторный запуск миграций ничего не меняет и завершается успешно ... ok +test_secrets_are_not_stored_in_plaintext (test_db.DatabaseTest.test_secrets_are_not_stored_in_plaintext) +В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен ... ok + +---------------------------------------------------------------------- +Ran 36 tests in 11.556s + +OK + + отправлено 201: 100, уникальных id: 100, прочитано: 100 за 4 страниц(ы) diff --git a/evidence/track2/planner_random_page_cost_1_1.json b/evidence/track2/planner_random_page_cost_1_1.json new file mode 100644 index 00000000..2855d9af --- /dev/null +++ b/evidence/track2/planner_random_page_cost_1_1.json @@ -0,0 +1,29 @@ +{ + "big_d50_offset": { + "median_ms": 11.508, + "p95_ms": 12.992, + "planning_ms": 0.061, + "shared_hit": 8064, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "big_d90_offset": { + "median_ms": 21.338, + "p95_ms": 21.923, + "planning_ms": 0.074, + "shared_hit": 14567, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "medium_d90_offset": { + "median_ms": 0.683, + "p95_ms": 0.728, + "planning_ms": 0.042, + "shared_hit": 2499, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + } +} diff --git a/evidence/track2/planner_random_page_cost_4.json b/evidence/track2/planner_random_page_cost_4.json new file mode 100644 index 00000000..9cb3aac4 --- /dev/null +++ b/evidence/track2/planner_random_page_cost_4.json @@ -0,0 +1,29 @@ +{ + "big_d50_offset": { + "median_ms": 10.606, + "p95_ms": 11.549, + "planning_ms": 0.06, + "shared_hit": 8064, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "big_d90_offset": { + "median_ms": 120.438, + "p95_ms": 127.612, + "planning_ms": 0.085, + "shared_hit": 7865, + "shared_read": 4846, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_d90_offset": { + "median_ms": 5.041, + "p95_ms": 5.433, + "planning_ms": 0.055, + "shared_hit": 2713, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(messages_chat_history_idx)" + } +} diff --git a/evidence/track2/reads.json b/evidence/track2/reads.json new file mode 100644 index 00000000..cf070928 --- /dev/null +++ b/evidence/track2/reads.json @@ -0,0 +1,578 @@ +{ + "environment": { + "date": "2026-10-29T08:55:57Z", + "docker_cpus": 12, + "docker_memory_gib": 1.9, + "docker_server": "27.2.0", + "postgres": "17.11", + "shared_buffers": "128MB" + }, + "runs": 15, + "warmup": 3, + "variants": { + "pk_only": { + "build_seconds": 0.0, + "index_bytes": 0, + "queries": { + "big_first": { + "median_ms": 31.636, + "p95_ms": 33.929, + "planning_ms": 0.068, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "big_d50_keyset": { + "median_ms": 29.115, + "p95_ms": 45.68, + "planning_ms": 0.083, + "shared_hit": 12303, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "big_d50_offset": { + "median_ms": 116.405, + "p95_ms": 142.333, + "planning_ms": 0.074, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "big_d90_keyset": { + "median_ms": 25.118, + "p95_ms": 27.994, + "planning_ms": 0.078, + "shared_hit": 12303, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "big_d90_offset": { + "median_ms": 135.534, + "p95_ms": 144.718, + "planning_ms": 0.074, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_first": { + "median_ms": 23.077, + "p95_ms": 23.909, + "planning_ms": 0.068, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_d50_keyset": { + "median_ms": 26.5, + "p95_ms": 31.003, + "planning_ms": 0.081, + "shared_hit": 12303, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_d50_offset": { + "median_ms": 24.115, + "p95_ms": 26.148, + "planning_ms": 0.069, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_d90_keyset": { + "median_ms": 23.375, + "p95_ms": 25.052, + "planning_ms": 0.08, + "shared_hit": 12303, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_d90_offset": { + "median_ms": 23.633, + "p95_ms": 24.813, + "planning_ms": 0.067, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "small_first": { + "median_ms": 20.085, + "p95_ms": 21.647, + "planning_ms": 0.064, + "shared_hit": 12361, + "shared_read": 0, + "rows": 10, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "small_d50_keyset": { + "median_ms": 22.948, + "p95_ms": 25.171, + "planning_ms": 0.08, + "shared_hit": 12273, + "shared_read": 0, + "rows": 5, + "plan": "Limit > Sort > Gather > Seq Scan" + }, + "small_d50_offset": { + "median_ms": 21.521, + "p95_ms": 23.739, + "planning_ms": 0.066, + "shared_hit": 12361, + "shared_read": 0, + "rows": 5, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "small_d90_keyset": { + "median_ms": 22.477, + "p95_ms": 25.176, + "planning_ms": 0.081, + "shared_hit": 12273, + "shared_read": 0, + "rows": 1, + "plan": "Limit > Sort > Gather > Seq Scan" + }, + "small_d90_offset": { + "median_ms": 22.451, + "p95_ms": 24.216, + "planning_ms": 0.068, + "shared_hit": 12361, + "shared_read": 0, + "rows": 1, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + } + } + }, + "chat_id": { + "build_seconds": 0.43, + "index_bytes": 1572864, + "queries": { + "big_first": { + "median_ms": 29.135, + "p95_ms": 34.976, + "planning_ms": 0.077, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "big_d50_keyset": { + "median_ms": 28.754, + "p95_ms": 30.474, + "planning_ms": 0.093, + "shared_hit": 12303, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "big_d50_offset": { + "median_ms": 114.655, + "p95_ms": 118.28, + "planning_ms": 0.081, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "big_d90_keyset": { + "median_ms": 25.87, + "p95_ms": 28.291, + "planning_ms": 0.088, + "shared_hit": 12303, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "big_d90_offset": { + "median_ms": 130.247, + "p95_ms": 139.705, + "planning_ms": 0.086, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_first": { + "median_ms": 3.504, + "p95_ms": 3.65, + "planning_ms": 0.058, + "shared_hit": 2695, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" + }, + "medium_d50_keyset": { + "median_ms": 3.528, + "p95_ms": 4.512, + "planning_ms": 0.073, + "shared_hit": 2695, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" + }, + "medium_d50_offset": { + "median_ms": 6.258, + "p95_ms": 6.974, + "planning_ms": 0.071, + "shared_hit": 2695, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" + }, + "medium_d90_keyset": { + "median_ms": 3.442, + "p95_ms": 4.265, + "planning_ms": 0.076, + "shared_hit": 2695, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" + }, + "medium_d90_offset": { + "median_ms": 6.063, + "p95_ms": 6.213, + "planning_ms": 0.061, + "shared_hit": 2695, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" + }, + "small_first": { + "median_ms": 0.061, + "p95_ms": 0.064, + "planning_ms": 0.041, + "shared_hit": 13, + "shared_read": 0, + "rows": 10, + "plan": "Limit > Sort > Index Scan(bench_chat_idx)" + }, + "small_d50_keyset": { + "median_ms": 0.064, + "p95_ms": 0.098, + "planning_ms": 0.05, + "shared_hit": 13, + "shared_read": 0, + "rows": 5, + "plan": "Limit > Sort > Index Scan(bench_chat_idx)" + }, + "small_d50_offset": { + "median_ms": 0.079, + "p95_ms": 0.1, + "planning_ms": 0.044, + "shared_hit": 13, + "shared_read": 0, + "rows": 5, + "plan": "Limit > Sort > Index Scan(bench_chat_idx)" + }, + "small_d90_keyset": { + "median_ms": 0.067, + "p95_ms": 0.108, + "planning_ms": 0.05, + "shared_hit": 13, + "shared_read": 0, + "rows": 1, + "plan": "Limit > Sort > Index Scan(bench_chat_idx)" + }, + "small_d90_offset": { + "median_ms": 0.087, + "p95_ms": 0.116, + "planning_ms": 0.055, + "shared_hit": 13, + "shared_read": 0, + "rows": 1, + "plan": "Limit > Sort > Index Scan(bench_chat_idx)" + } + } + }, + "created_at_id": { + "build_seconds": 0.48, + "index_bytes": 8126464, + "queries": { + "big_first": { + "median_ms": 0.055, + "p95_ms": 0.078, + "planning_ms": 0.026, + "shared_hit": 9, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "big_d50_keyset": { + "median_ms": 0.056, + "p95_ms": 0.063, + "planning_ms": 0.05, + "shared_hit": 18, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "big_d50_offset": { + "median_ms": 22.942, + "p95_ms": 23.121, + "planning_ms": 0.053, + "shared_hit": 9806, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "big_d90_keyset": { + "median_ms": 0.057, + "p95_ms": 0.077, + "planning_ms": 0.053, + "shared_hit": 17, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "big_d90_offset": { + "median_ms": 41.109, + "p95_ms": 41.439, + "planning_ms": 0.064, + "shared_hit": 17650, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "medium_first": { + "median_ms": 0.349, + "p95_ms": 0.378, + "planning_ms": 0.025, + "shared_hit": 327, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "medium_d50_keyset": { + "median_ms": 0.419, + "p95_ms": 0.49, + "planning_ms": 0.049, + "shared_hit": 375, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "medium_d50_offset": { + "median_ms": 23.305, + "p95_ms": 24.069, + "planning_ms": 0.074, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_d90_keyset": { + "median_ms": 0.354, + "p95_ms": 0.399, + "planning_ms": 0.05, + "shared_hit": 314, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "medium_d90_offset": { + "median_ms": 23.641, + "p95_ms": 24.668, + "planning_ms": 0.075, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "small_first": { + "median_ms": 21.749, + "p95_ms": 22.376, + "planning_ms": 0.078, + "shared_hit": 12361, + "shared_read": 0, + "rows": 10, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "small_d50_keyset": { + "median_ms": 24.374, + "p95_ms": 25.062, + "planning_ms": 0.092, + "shared_hit": 12273, + "shared_read": 0, + "rows": 5, + "plan": "Limit > Sort > Gather > Seq Scan" + }, + "small_d50_offset": { + "median_ms": 21.753, + "p95_ms": 22.948, + "planning_ms": 0.078, + "shared_hit": 12361, + "shared_read": 0, + "rows": 5, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "small_d90_keyset": { + "median_ms": 0.824, + "p95_ms": 1.122, + "planning_ms": 0.055, + "shared_hit": 548, + "shared_read": 0, + "rows": 1, + "plan": "Limit > Index Scan(bench_time_idx)" + }, + "small_d90_offset": { + "median_ms": 20.675, + "p95_ms": 23.105, + "planning_ms": 0.078, + "shared_hit": 12361, + "shared_read": 0, + "rows": 1, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + } + } + }, + "chat_created_id": { + "build_seconds": 0.53, + "index_bytes": 11796480, + "queries": { + "big_first": { + "median_ms": 0.057, + "p95_ms": 0.07, + "planning_ms": 0.049, + "shared_hit": 9, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "big_d50_keyset": { + "median_ms": 0.048, + "p95_ms": 0.076, + "planning_ms": 0.054, + "shared_hit": 13, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "big_d50_offset": { + "median_ms": 11.673, + "p95_ms": 12.276, + "planning_ms": 0.061, + "shared_hit": 8064, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "big_d90_keyset": { + "median_ms": 0.054, + "p95_ms": 0.073, + "planning_ms": 0.053, + "shared_hit": 11, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "big_d90_offset": { + "median_ms": 132.109, + "p95_ms": 137.947, + "planning_ms": 0.085, + "shared_hit": 12361, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Gather Merge > Sort > Seq Scan" + }, + "medium_first": { + "median_ms": 0.051, + "p95_ms": 0.072, + "planning_ms": 0.041, + "shared_hit": 50, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "medium_d50_keyset": { + "median_ms": 0.056, + "p95_ms": 0.093, + "planning_ms": 0.052, + "shared_hit": 48, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "medium_d50_offset": { + "median_ms": 0.43, + "p95_ms": 0.472, + "planning_ms": 0.04, + "shared_hit": 1408, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "medium_d90_keyset": { + "median_ms": 0.057, + "p95_ms": 0.085, + "planning_ms": 0.05, + "shared_hit": 49, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "medium_d90_offset": { + "median_ms": 5.539, + "p95_ms": 6.149, + "planning_ms": 0.058, + "shared_hit": 2713, + "shared_read": 0, + "rows": 51, + "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(messages_chat_history_idx)" + }, + "small_first": { + "median_ms": 0.039, + "p95_ms": 0.059, + "planning_ms": 0.039, + "shared_hit": 13, + "shared_read": 0, + "rows": 10, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "small_d50_keyset": { + "median_ms": 0.05, + "p95_ms": 0.069, + "planning_ms": 0.065, + "shared_hit": 8, + "shared_read": 0, + "rows": 5, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "small_d50_offset": { + "median_ms": 0.038, + "p95_ms": 0.049, + "planning_ms": 0.041, + "shared_hit": 13, + "shared_read": 0, + "rows": 5, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "small_d90_keyset": { + "median_ms": 0.038, + "p95_ms": 0.069, + "planning_ms": 0.054, + "shared_hit": 4, + "shared_read": 0, + "rows": 1, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + }, + "small_d90_offset": { + "median_ms": 0.046, + "p95_ms": 0.073, + "planning_ms": 0.054, + "shared_hit": 13, + "shared_read": 0, + "rows": 1, + "plan": "Limit > Index Scan(messages_chat_history_idx)" + } + } + } + } +} diff --git a/evidence/track2/restore.json b/evidence/track2/restore.json new file mode 100644 index 00000000..3712855d --- /dev/null +++ b/evidence/track2/restore.json @@ -0,0 +1,52 @@ +{ + "environment": { + "date": "2026-10-29T09:19:01Z", + "docker_cpus": 12, + "docker_memory_gib": 1.9, + "docker_server": "27.2.0", + "postgres": "17.11", + "shared_buffers": "128MB" + }, + "dump_bytes": 14099013, + "times_seconds": { + "dump_bench": 1.69, + "dump_messenger": 0.51, + "copy": 1.52, + "restore_bench": 2.36, + "restore_messenger": 0.42, + "analyze": 0.74, + "api_restore_ready": 6.74 + }, + "rto_seconds": 13.98, + "source": { + "users": "1000", + "chats": "4021", + "chat_members": "8600", + "messages": "200000", + "all_messages_md5": "f3e491b7ebfb52972c8ee73470a90926", + "big_first_page_md5": "516a32c3f0dce2566e84161528ea595c", + "big_d90_page_md5": "52b8761a011eae861bb3518ea2685698", + "small_chat_md5": "cd1b0184a9133cc7f0f688ab21b713d9" + }, + "restored": { + "users": "1000", + "chats": "4021", + "chat_members": "8600", + "messages": "200000", + "all_messages_md5": "f3e491b7ebfb52972c8ee73470a90926", + "big_first_page_md5": "516a32c3f0dce2566e84161528ea595c", + "big_d90_page_md5": "52b8761a011eae861bb3518ea2685698", + "small_chat_md5": "cd1b0184a9133cc7f0f688ab21b713d9" + }, + "mismatches": [], + "concurrent_writes": { + "committed_before_dump_start": 3787, + "committed_total": 11172, + "present_in_backup": 4482, + "lost_after_snapshot": 6690 + }, + "api_restore": { + "old_token_users_me": 200, + "message_matches": true + } +} diff --git a/evidence/track2/results.md b/evidence/track2/results.md new file mode 100644 index 00000000..97c87601 --- /dev/null +++ b/evidence/track2/results.md @@ -0,0 +1,111 @@ +# Трек 2: результаты + +Среда: `{"date": "2026-10-29T08:55:57Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB"}` + +## Чтение страницы истории (LIMIT 51), медиана из 15 прогонов, мс + +| запрос | pk_only | chat_id | created_at_id | chat_created_id | +|---|---|---|---|---| +| big_first | 31.636 | 29.135 | 0.055 | 0.057 | +| big_d50_keyset | 29.115 | 28.754 | 0.056 | 0.048 | +| big_d50_offset | 116.405 | 114.655 | 22.942 | 11.673 | +| big_d90_keyset | 25.118 | 25.870 | 0.057 | 0.054 | +| big_d90_offset | 135.534 | 130.247 | 41.109 | 132.109 | +| medium_first | 23.077 | 3.504 | 0.349 | 0.051 | +| medium_d50_keyset | 26.500 | 3.528 | 0.419 | 0.056 | +| medium_d50_offset | 24.115 | 6.258 | 23.305 | 0.430 | +| medium_d90_keyset | 23.375 | 3.442 | 0.354 | 0.057 | +| medium_d90_offset | 23.633 | 6.063 | 23.641 | 5.539 | +| small_first | 20.085 | 0.061 | 21.749 | 0.039 | +| small_d50_keyset | 22.948 | 0.064 | 24.374 | 0.050 | +| small_d50_offset | 21.521 | 0.079 | 21.753 | 0.038 | +| small_d90_keyset | 22.477 | 0.067 | 0.824 | 0.038 | +| small_d90_offset | 22.451 | 0.087 | 20.675 | 0.046 | + +## Буферы (shared hit + read) на запрос + +| запрос | pk_only | chat_id | created_at_id | chat_created_id | +|---|---|---|---|---| +| big_first | 12361 | 12361 | 9 | 9 | +| big_d50_keyset | 12303 | 12303 | 18 | 13 | +| big_d50_offset | 12361 | 12361 | 9806 | 8064 | +| big_d90_keyset | 12303 | 12303 | 17 | 11 | +| big_d90_offset | 12361 | 12361 | 17650 | 12361 | +| medium_first | 12361 | 2695 | 327 | 50 | +| medium_d50_keyset | 12303 | 2695 | 375 | 48 | +| medium_d50_offset | 12361 | 2695 | 12361 | 1408 | +| medium_d90_keyset | 12303 | 2695 | 314 | 49 | +| medium_d90_offset | 12361 | 2695 | 12361 | 2713 | +| small_first | 12361 | 13 | 12361 | 13 | +| small_d50_keyset | 12273 | 13 | 12273 | 8 | +| small_d50_offset | 12361 | 13 | 12361 | 13 | +| small_d90_keyset | 12273 | 13 | 548 | 4 | +| small_d90_offset | 12361 | 13 | 12361 | 13 | + +## Планы + +- pk_only / big_first: `Limit > Gather Merge > Sort > Seq Scan` +- pk_only / big_d90_keyset: `Limit > Gather Merge > Sort > Seq Scan` +- pk_only / big_d90_offset: `Limit > Gather Merge > Sort > Seq Scan` +- pk_only / small_first: `Limit > Gather Merge > Sort > Seq Scan` +- chat_id / big_first: `Limit > Gather Merge > Sort > Seq Scan` +- chat_id / big_d90_keyset: `Limit > Gather Merge > Sort > Seq Scan` +- chat_id / big_d90_offset: `Limit > Gather Merge > Sort > Seq Scan` +- chat_id / small_first: `Limit > Sort > Index Scan(bench_chat_idx)` +- created_at_id / big_first: `Limit > Index Scan(bench_time_idx)` +- created_at_id / big_d90_keyset: `Limit > Index Scan(bench_time_idx)` +- created_at_id / big_d90_offset: `Limit > Index Scan(bench_time_idx)` +- created_at_id / small_first: `Limit > Gather Merge > Sort > Seq Scan` +- chat_created_id / big_first: `Limit > Index Scan(messages_chat_history_idx)` +- chat_created_id / big_d90_keyset: `Limit > Index Scan(messages_chat_history_idx)` +- chat_created_id / big_d90_offset: `Limit > Gather Merge > Sort > Seq Scan` +- chat_created_id / small_first: `Limit > Index Scan(messages_chat_history_idx)` + +## Индексы: размер и время построения + +| вариант | размер индексов, MiB | построение, с | +|---|---|---| +| pk_only | 0.0 | 0.00 | +| chat_id | 1.5 | 0.43 | +| created_at_id | 7.8 | 0.48 | +| chat_created_id | 11.2 | 0.53 | + +## Запись + +Пакет: EXPLAIN ANALYZE INSERT 20000 строк в транзакции с ROLLBACK, после CHECKPOINT (медиана 5) — без шума fsync commit. pgbench: по одной строке на транзакцию с COMMIT, 4 клиента, 10 с x 5 повторов. + +| вариант | INSERT (таблица+индексы), мс/1000 | FK-проверка, мс/1000 | всего, мс/1000 | WAL на строку, байт | pgbench TPS медиана [min..max] | latency, мс | +|---|---|---|---|---|---|---| +| pk_only | 9.80 | 31.30 | 41.46 | 2793 | 784.2 [528.9..3583.6] | 5.101 | +| chat_id | 11.24 | 30.13 | 41.14 | 2951 | 3541.4 [2776.1..3601.4] | 1.129 | +| created_at_id | 10.85 | 30.81 | 41.22 | 2877 | 3491.3 [3477.0..3522.1] | 1.146 | +| chat_created_id | 11.79 | 31.32 | 43.23 | 3036 | 3505.2 [2773.7..3540.0] | 1.141 | +| chat_created_id_plus_time | 12.78 | 30.83 | 44.16 | 3121 | 3552.6 [783.2..3578.8] | 1.126 | + +## Backup -> restore + +| этап | секунд | +|---|---| +| dump_bench | 1.69 | +| dump_messenger | 0.51 | +| copy | 1.52 | +| restore_bench | 2.36 | +| restore_messenger | 0.42 | +| analyze | 0.74 | +| api_restore_ready | 6.74 | +| **итого (RTO на этом стенде)** | **13.98** | + +Размер bench.dump: 13.4 MiB. Несовпадения контрольных сумм: нет. +Запись во время дампа: {"committed_before_dump_start": 3787, "committed_total": 11172, "present_in_backup": 4482, "lost_after_snapshot": 6690}. +API на восстановленной БД: {"old_token_users_me": 200, "message_matches": true}. + +| проверка | источник | восстановлено | +|---|---|---| +| users | `1000` | `1000` | +| chats | `4021` | `4021` | +| chat_members | `8600` | `8600` | +| messages | `200000` | `200000` | +| all_messages_md5 | `f3e491b7ebfb52972c8ee73470a90926` | `f3e491b7ebfb52972c8ee73470a90926` | +| big_first_page_md5 | `516a32c3f0dce2566e84161528ea595c` | `516a32c3f0dce2566e84161528ea595c` | +| big_d90_page_md5 | `52b8761a011eae861bb3518ea2685698` | `52b8761a011eae861bb3518ea2685698` | +| small_chat_md5 | `cd1b0184a9133cc7f0f688ab21b713d9` | `cd1b0184a9133cc7f0f688ab21b713d9` | diff --git a/evidence/track2/writes.json b/evidence/track2/writes.json new file mode 100644 index 00000000..a71e9fc8 --- /dev/null +++ b/evidence/track2/writes.json @@ -0,0 +1,386 @@ +{ + "environment": { + "date": "2026-10-29T09:10:50Z", + "docker_cpus": 12, + "docker_memory_gib": 1.9, + "docker_server": "27.2.0", + "postgres": "17.11", + "shared_buffers": "128MB" + }, + "seconds": 10, + "clients": 4, + "repeats": 5, + "bulk_rows": 20000, + "variants": { + "pk_only": { + "bulk_insert_ms_per_1000": 9.8, + "bulk_fk_ms_per_1000": 31.3, + "bulk_total_ms_per_1000": 41.46, + "bulk_wal_bytes_per_row": 2793, + "tps_median": 784.2, + "tps_min": 528.9, + "tps_max": 3583.6, + "latency_ms_median": 5.101, + "bulks": [ + { + "insert_ms_per_1000": 9.8, + "fk_ms_per_1000": 31.52, + "total_ms_per_1000": 41.47, + "wal_bytes_per_row": 2793 + }, + { + "insert_ms_per_1000": 11.09, + "fk_ms_per_1000": 30.56, + "total_ms_per_1000": 41.76, + "wal_bytes_per_row": 2793 + }, + { + "insert_ms_per_1000": 9.43, + "fk_ms_per_1000": 31.91, + "total_ms_per_1000": 41.46, + "wal_bytes_per_row": 2793 + }, + { + "insert_ms_per_1000": 9.95, + "fk_ms_per_1000": 31.3, + "total_ms_per_1000": 41.36, + "wal_bytes_per_row": 2793 + }, + { + "insert_ms_per_1000": 9.5, + "fk_ms_per_1000": 30.65, + "total_ms_per_1000": 40.27, + "wal_bytes_per_row": 2793 + } + ], + "attempts": [ + { + "tps": 3513.544906, + "latency_ms": 1.138, + "transactions": 35120, + "wal_bytes_per_insert": 1769 + }, + { + "tps": 3583.592907, + "latency_ms": 1.116, + "transactions": 35820, + "wal_bytes_per_insert": 1741 + }, + { + "tps": 784.216324, + "latency_ms": 5.101, + "transactions": 7843, + "wal_bytes_per_insert": 6893 + }, + { + "tps": 661.032239, + "latency_ms": 6.051, + "transactions": 6616, + "wal_bytes_per_insert": 7164 + }, + { + "tps": 528.938348, + "latency_ms": 7.562, + "transactions": 5289, + "wal_bytes_per_insert": 7348 + } + ] + }, + "chat_id": { + "bulk_insert_ms_per_1000": 11.24, + "bulk_fk_ms_per_1000": 30.13, + "bulk_total_ms_per_1000": 41.14, + "bulk_wal_bytes_per_row": 2951, + "tps_median": 3541.4, + "tps_min": 2776.1, + "tps_max": 3601.4, + "latency_ms_median": 1.129, + "bulks": [ + { + "insert_ms_per_1000": 11.24, + "fk_ms_per_1000": 30.74, + "total_ms_per_1000": 42.09, + "wal_bytes_per_row": 2946 + }, + { + "insert_ms_per_1000": 11.26, + "fk_ms_per_1000": 29.76, + "total_ms_per_1000": 41.14, + "wal_bytes_per_row": 2954 + }, + { + "insert_ms_per_1000": 10.71, + "fk_ms_per_1000": 30.13, + "total_ms_per_1000": 40.95, + "wal_bytes_per_row": 2951 + }, + { + "insert_ms_per_1000": 11.43, + "fk_ms_per_1000": 30.85, + "total_ms_per_1000": 42.4, + "wal_bytes_per_row": 2951 + }, + { + "insert_ms_per_1000": 11.08, + "fk_ms_per_1000": 29.95, + "total_ms_per_1000": 41.14, + "wal_bytes_per_row": 2954 + } + ], + "attempts": [ + { + "tps": 3526.596885, + "latency_ms": 1.134, + "transactions": 35252, + "wal_bytes_per_insert": 1896 + }, + { + "tps": 3541.427104, + "latency_ms": 1.129, + "transactions": 35402, + "wal_bytes_per_insert": 1887 + }, + { + "tps": 3552.604368, + "latency_ms": 1.126, + "transactions": 35508, + "wal_bytes_per_insert": 1885 + }, + { + "tps": 3601.44502, + "latency_ms": 1.111, + "transactions": 35996, + "wal_bytes_per_insert": 1866 + }, + { + "tps": 2776.112606, + "latency_ms": 1.441, + "transactions": 27749, + "wal_bytes_per_insert": 2310 + } + ] + }, + "created_at_id": { + "bulk_insert_ms_per_1000": 10.85, + "bulk_fk_ms_per_1000": 30.81, + "bulk_total_ms_per_1000": 41.22, + "bulk_wal_bytes_per_row": 2877, + "tps_median": 3491.3, + "tps_min": 3477.0, + "tps_max": 3522.1, + "latency_ms_median": 1.146, + "bulks": [ + { + "insert_ms_per_1000": 10.85, + "fk_ms_per_1000": 30.26, + "total_ms_per_1000": 41.22, + "wal_bytes_per_row": 2877 + }, + { + "insert_ms_per_1000": 10.84, + "fk_ms_per_1000": 30.82, + "total_ms_per_1000": 41.78, + "wal_bytes_per_row": 2877 + }, + { + "insert_ms_per_1000": 11.47, + "fk_ms_per_1000": 30.81, + "total_ms_per_1000": 42.39, + "wal_bytes_per_row": 2877 + }, + { + "insert_ms_per_1000": 10.89, + "fk_ms_per_1000": 30.13, + "total_ms_per_1000": 41.12, + "wal_bytes_per_row": 2877 + }, + { + "insert_ms_per_1000": 9.92, + "fk_ms_per_1000": 30.84, + "total_ms_per_1000": 40.88, + "wal_bytes_per_row": 2877 + } + ], + "attempts": [ + { + "tps": 3522.068729, + "latency_ms": 1.136, + "transactions": 35205, + "wal_bytes_per_insert": 1850 + }, + { + "tps": 3476.990375, + "latency_ms": 1.15, + "transactions": 34754, + "wal_bytes_per_insert": 1869 + }, + { + "tps": 3491.314235, + "latency_ms": 1.146, + "transactions": 34896, + "wal_bytes_per_insert": 1864 + }, + { + "tps": 3486.483623, + "latency_ms": 1.147, + "transactions": 34848, + "wal_bytes_per_insert": 1866 + }, + { + "tps": 3517.088554, + "latency_ms": 1.137, + "transactions": 35154, + "wal_bytes_per_insert": 1854 + } + ] + }, + "chat_created_id": { + "bulk_insert_ms_per_1000": 11.79, + "bulk_fk_ms_per_1000": 31.32, + "bulk_total_ms_per_1000": 43.23, + "bulk_wal_bytes_per_row": 3036, + "tps_median": 3505.2, + "tps_min": 2773.7, + "tps_max": 3540.0, + "latency_ms_median": 1.141, + "bulks": [ + { + "insert_ms_per_1000": 12.47, + "fk_ms_per_1000": 32.83, + "total_ms_per_1000": 45.41, + "wal_bytes_per_row": 3060 + }, + { + "insert_ms_per_1000": 11.61, + "fk_ms_per_1000": 31.36, + "total_ms_per_1000": 43.1, + "wal_bytes_per_row": 3036 + }, + { + "insert_ms_per_1000": 11.07, + "fk_ms_per_1000": 29.45, + "total_ms_per_1000": 40.65, + "wal_bytes_per_row": 3036 + }, + { + "insert_ms_per_1000": 13.25, + "fk_ms_per_1000": 30.65, + "total_ms_per_1000": 44.01, + "wal_bytes_per_row": 3036 + }, + { + "insert_ms_per_1000": 11.79, + "fk_ms_per_1000": 31.32, + "total_ms_per_1000": 43.23, + "wal_bytes_per_row": 3036 + } + ], + "attempts": [ + { + "tps": 3531.073941, + "latency_ms": 1.133, + "transactions": 35297, + "wal_bytes_per_insert": 1976 + }, + { + "tps": 3481.74199, + "latency_ms": 1.149, + "transactions": 34801, + "wal_bytes_per_insert": 1984 + }, + { + "tps": 3540.023992, + "latency_ms": 1.13, + "transactions": 35383, + "wal_bytes_per_insert": 1959 + }, + { + "tps": 3505.193506, + "latency_ms": 1.141, + "transactions": 35033, + "wal_bytes_per_insert": 1970 + }, + { + "tps": 2773.668269, + "latency_ms": 1.442, + "transactions": 27725, + "wal_bytes_per_insert": 2375 + } + ] + }, + "chat_created_id_plus_time": { + "bulk_insert_ms_per_1000": 12.78, + "bulk_fk_ms_per_1000": 30.83, + "bulk_total_ms_per_1000": 44.16, + "bulk_wal_bytes_per_row": 3121, + "tps_median": 3552.6, + "tps_min": 783.2, + "tps_max": 3578.8, + "latency_ms_median": 1.126, + "bulks": [ + { + "insert_ms_per_1000": 13.27, + "fk_ms_per_1000": 30.77, + "total_ms_per_1000": 44.16, + "wal_bytes_per_row": 3145 + }, + { + "insert_ms_per_1000": 12.78, + "fk_ms_per_1000": 31.66, + "total_ms_per_1000": 44.55, + "wal_bytes_per_row": 3120 + }, + { + "insert_ms_per_1000": 13.64, + "fk_ms_per_1000": 30.82, + "total_ms_per_1000": 44.57, + "wal_bytes_per_row": 3121 + }, + { + "insert_ms_per_1000": 12.73, + "fk_ms_per_1000": 30.83, + "total_ms_per_1000": 43.68, + "wal_bytes_per_row": 3121 + }, + { + "insert_ms_per_1000": 11.77, + "fk_ms_per_1000": 31.53, + "total_ms_per_1000": 43.43, + "wal_bytes_per_row": 3121 + } + ], + "attempts": [ + { + "tps": 3554.292554, + "latency_ms": 1.125, + "transactions": 35526, + "wal_bytes_per_insert": 2052 + }, + { + "tps": 3552.622838, + "latency_ms": 1.126, + "transactions": 35510, + "wal_bytes_per_insert": 2039 + }, + { + "tps": 3578.846119, + "latency_ms": 1.118, + "transactions": 35771, + "wal_bytes_per_insert": 2025 + }, + { + "tps": 3376.236061, + "latency_ms": 1.185, + "transactions": 33745, + "wal_bytes_per_insert": 2115 + }, + { + "tps": 783.210401, + "latency_ms": 5.107, + "transactions": 7833, + "wal_bytes_per_insert": 7365 + } + ] + } + } +} diff --git a/research/seed.sql b/research/seed.sql new file mode 100644 index 00000000..e0af74f0 --- /dev/null +++ b/research/seed.sql @@ -0,0 +1,62 @@ +SELECT setseed(0.42); + +INSERT INTO users (username, display_name, password_hash, created_at) +SELECT 'bench_' || lpad(g::text, 4, '0'), 'Bench ' || g, 'synthetic-no-login', timestamptz '2026-08-01 00:00:00Z' +FROM generate_series(0, 999) AS g; + +CREATE TABLE bench_users AS +SELECT id, (substr(username, 7))::int AS n FROM users WHERE username LIKE 'bench\_%'; +CREATE UNIQUE INDEX ON bench_users (n); + +CREATE TABLE bench_chats AS +SELECT gen_random_uuid() AS id, p.kind, p.messages, p.members, row_number() OVER () AS rn +FROM (VALUES ('big', 1, 100000, 200), ('medium', 20, 3000, 20), ('small', 4000, 10, 2)) + AS p(kind, chats, messages, members) +CROSS JOIN LATERAL generate_series(1, p.chats); + +INSERT INTO chats (id, title, created_by, created_at) +SELECT c.id, c.kind || ' ' || c.rn, u.id, timestamptz '2026-08-31 00:00:00Z' +FROM bench_chats c JOIN bench_users u ON u.n = (c.rn * 37) % 1000; + +INSERT INTO chat_members (chat_id, user_id, position) +SELECT c.id, u.id, k + 1 +FROM bench_chats c +CROSS JOIN LATERAL generate_series(0, c.members - 1) AS k +JOIN bench_users u ON u.n = (c.rn * 37 + k) % 1000; + +INSERT INTO messages (chat_id, sender_id, text, created_at) +SELECT m.chat_id, u.id, left(repeat('Синтетическое сообщение ', 20), m.len), m.ts +FROM ( + SELECT c.id AS chat_id, c.rn, + (random() * (c.members - 1))::int AS k, + 20 + (random() * 380)::int AS len, + timestamptz '2026-09-01 00:00:00Z' + random() * interval '30 days' AS ts + FROM bench_chats c CROSS JOIN LATERAL generate_series(1, c.messages) +) AS m +JOIN bench_users u ON u.n = (m.rn * 37 + m.k) % 1000 +ORDER BY m.ts; + +CREATE TABLE bench_targets AS +SELECT row_number() OVER () AS n, chat_id, sender_id +FROM (SELECT chat_id, sender_id FROM messages ORDER BY random() LIMIT 10000) AS s; +CREATE UNIQUE INDEX ON bench_targets (n); + +CREATE TABLE bench_cursors AS +SELECT c.kind, c.id AS chat_id, d.depth, (c.messages * d.depth)::int AS skip, m.created_at, m.id +FROM (SELECT DISTINCT ON (kind) id, kind, messages FROM bench_chats ORDER BY kind, rn) AS c +CROSS JOIN (VALUES (0.5), (0.9)) AS d(depth) +CROSS JOIN LATERAL ( + SELECT created_at, id FROM messages WHERE chat_id = c.id + ORDER BY created_at, id OFFSET (c.messages * d.depth)::int - 1 LIMIT 1 +) AS m; + +CREATE OR REPLACE FUNCTION bench_explain(query text) RETURNS jsonb LANGUAGE plpgsql AS $$ +DECLARE + result json; +BEGIN + EXECUTE 'EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ' || query INTO result; + RETURN result::jsonb; +END +$$; + +VACUUM ANALYZE; diff --git a/research/track2.py b/research/track2.py new file mode 100644 index 00000000..6d56ed9b --- /dev/null +++ b/research/track2.py @@ -0,0 +1,397 @@ +"""Трек 2: план запроса истории, стоимость записи, backup -> restore -> сверка. + +Стенд должен быть запущен (docker compose up -d). Данные — синтетические, в отдельной БД bench. + python research/track2.py prepare # БД bench: 200 000 сообщений в чатах разного размера + python research/track2.py reads # 4 варианта индекса x запросы -> evidence/track2/reads.json + python research/track2.py writes # pgbench INSERT для каждого варианта -> evidence/track2/writes.json + python research/track2.py explain # EXPLAIN (ANALYZE, BUFFERS) рабочего индекса -> evidence/explain-history.txt + python research/track2.py restore # pg_dump -> новый postgres-restore -> сверка -> evidence/track2/restore.json + python research/track2.py report # evidence/track2/results.md из JSON + python research/track2.py all +""" +import base64 +from datetime import datetime, timezone +import json +from pathlib import Path +import re +import statistics +import subprocess +import sys +import time +import urllib.error +import urllib.request +import uuid + +ROOT = Path(__file__).resolve().parents[1] +OUT = ROOT / 'evidence' / 'track2' +WARMUP, RUNS = 3, 15 +PROJECT_VOLUME = 'grigoriev-lab2_pgdata_restore' + +VARIANTS = { + 'pk_only': [], + 'chat_id': ['CREATE INDEX bench_chat_idx ON messages (chat_id)'], + 'created_at_id': ['CREATE INDEX bench_time_idx ON messages (created_at, id)'], + 'chat_created_id': ['CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id)'], +} +WRITE_VARIANTS = dict(VARIANTS, chat_created_id_plus_time=VARIANTS['chat_created_id'] + VARIANTS['created_at_id']) +COLUMNS = 'id, chat_id, sender_id, text, created_at' + + +def run(args, stdin=None, check=True): + result = subprocess.run(args, cwd=ROOT, input=stdin, capture_output=True, text=True, encoding='utf-8') + if check and result.returncode != 0: + raise SystemExit('%s failed:\n%s' % (' '.join(args[:6]), result.stderr.strip())) + return result.stdout.strip() + + +def compose(*args, **kwargs): + return run(['docker', 'compose', '--profile', 'restore', *args], **kwargs) + + +def psql(sql, db='bench', service='postgres'): + return compose('exec', '-T', service, 'psql', '-U', 'messenger', '-d', db, '-X', '-q', '-tA', + '-v', 'ON_ERROR_STOP=1', stdin=sql) + + +def save(name, data): + OUT.mkdir(parents=True, exist_ok=True) + (OUT / name).write_text(json.dumps(data, ensure_ascii=False, indent=2) + '\n', encoding='utf-8') + print('saved evidence/track2/' + name) + + +def load(name): + return json.loads((OUT / name).read_text(encoding='utf-8')) + + +def environment(): + info = run(['docker', 'info', '--format', '{{.NCPU}} {{.MemTotal}} {{.ServerVersion}}']).split() + return {'date': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'), + 'docker_cpus': int(info[0]), 'docker_memory_gib': round(int(info[1]) / 2 ** 30, 1), + 'docker_server': info[2], 'postgres': psql('SHOW server_version', db='messenger'), + 'shared_buffers': psql('SHOW shared_buffers', db='messenger')} + + +def prepare(): + psql('DROP DATABASE IF EXISTS bench WITH (FORCE);', db='messenger') + psql('CREATE DATABASE bench;', db='messenger') + for path in sorted((ROOT / 'migrations').glob('*.sql')): + psql(path.read_text(encoding='utf-8')) + started = time.monotonic() + psql((ROOT / 'research' / 'seed.sql').read_text(encoding='utf-8')) + print('seed: %.1f s' % (time.monotonic() - started)) + print(psql("SELECT kind, count(*) AS chats, sum(messages) AS messages FROM bench_chats GROUP BY kind ORDER BY 3 DESC")) + print('messages:', psql('SELECT count(*) FROM messages'), + 'table size:', psql("SELECT pg_size_pretty(pg_table_size('messages'))")) + + +def use_variant(statements): + existing = psql("SELECT string_agg(indexname, ',') FROM pg_indexes WHERE tablename = 'messages' " + "AND indexname <> 'messages_pkey'") + if existing: + psql('DROP INDEX %s;' % existing) + started = time.monotonic() + for statement in statements: + psql(statement + ';') + build = time.monotonic() - started + psql('ANALYZE messages;') + size = int(psql("SELECT coalesce(sum(pg_relation_size(indexname::regclass)), 0) FROM pg_indexes " + "WHERE tablename = 'messages' AND indexname <> 'messages_pkey'")) + return build, size + + +def plan_shape(node): + name = node['Node Type'] + ('(%s)' % node['Index Name'] if 'Index Name' in node else '') + children = node.get('Plans', []) + return name + (' > ' + ' + '.join(plan_shape(c) for c in children) if children else '') + + +def queries(): + cursors = psql("SELECT kind, chat_id, depth, skip, created_at, id FROM bench_cursors ORDER BY kind, depth") + result = {} + for line in cursors.splitlines(): + kind, chat_id, depth, skip, created_at, message_id = line.split('|') + label = '%s_d%d' % (kind, round(float(depth) * 100)) + base = "SELECT %s FROM messages WHERE chat_id = '%s' " % (COLUMNS, chat_id) + result.setdefault('%s_first' % kind, base + 'ORDER BY created_at, id LIMIT 51') + result['%s_keyset' % label] = base + ("AND (created_at, id) > ('%s', '%s') ORDER BY created_at, id LIMIT 51" + % (created_at, message_id)) + result['%s_offset' % label] = base + 'ORDER BY created_at, id OFFSET %s LIMIT 51' % skip + return result + + +def measure(query): + calls = ''.join("SELECT bench_explain($q$%s$q$);\n" % query for _ in range(WARMUP + RUNS)) + plans = [json.loads(line)[0] for line in psql(calls).splitlines()][WARMUP:] + times = sorted(p['Execution Time'] for p in plans) + top = plans[-1]['Plan'] + return {'median_ms': round(statistics.median(times), 3), + 'p95_ms': round(times[int(len(times) * 0.95) - 1], 3), + 'planning_ms': round(statistics.median(p['Planning Time'] for p in plans), 3), + 'shared_hit': top.get('Shared Hit Blocks', 0), 'shared_read': top.get('Shared Read Blocks', 0), + 'rows': top['Actual Rows'], 'plan': plan_shape(top)} + + +def reads(): + data = {'environment': environment(), 'runs': RUNS, 'warmup': WARMUP, 'variants': {}} + for name, statements in VARIANTS.items(): + build, size = use_variant(statements) + results = {} + for label, query in queries().items(): + results[label] = measure(query) + print('%-16s %-22s %9.3f ms %s' % (name, label, results[label]['median_ms'], results[label]['plan'])) + data['variants'][name] = {'build_seconds': round(build, 2), 'index_bytes': size, 'queries': results} + use_variant(VARIANTS['chat_created_id']) + save('reads.json', data) + + +PGBENCH_SCRIPT = '''\\set n random(1, 10000) +INSERT INTO messages (chat_id, sender_id, text) SELECT chat_id, sender_id, '%s' FROM bench_targets WHERE n = :n; +''' + + +def pgbench(text, seconds, clients=4): + compose('exec', '-T', 'postgres', 'sh', '-c', 'cat > /tmp/insert.sql', stdin=PGBENCH_SCRIPT % text) + output = compose('exec', '-T', 'postgres', 'pgbench', '-U', 'messenger', '-n', '-c', str(clients), + '-j', str(clients), '-T', str(seconds), '-f', '/tmp/insert.sql', 'bench') + return {'tps': float(re.search(r'tps = ([\d.]+)', output).group(1)), + 'latency_ms': float(re.search(r'latency average = ([\d.]+) ms', output).group(1)), + 'transactions': int(re.search(r'actually processed: (\d+)', output).group(1))} + + +BULK_SQL = ("INSERT INTO messages (chat_id, sender_id, text) SELECT t.chat_id, t.sender_id, 'bulk write' " + "FROM generate_series(1, %d) AS g JOIN bench_targets t ON t.n = 1 + g %% 10000;") + + +def wal_since(lsn): + return int(psql("SELECT pg_wal_lsn_diff(pg_current_wal_lsn(), '%s')" % lsn)) + + +def bulk(rows): + psql('CHECKPOINT;') + before = psql('SELECT pg_current_wal_lsn()') + plan = json.loads(psql('BEGIN; SELECT bench_explain($q$%s$q$); ROLLBACK;' % (BULK_SQL % rows).rstrip(';')))[0] + wal = wal_since(before) + psql('VACUUM messages;') + per_1000 = 1000 / rows + fk_ms = sum(t['Time'] for t in plan.get('Triggers', [])) + return {'insert_ms_per_1000': round(plan['Plan']['Actual Total Time'] * per_1000, 2), + 'fk_ms_per_1000': round(fk_ms * per_1000, 2), + 'total_ms_per_1000': round(plan['Execution Time'] * per_1000, 2), + 'wal_bytes_per_row': round(wal / rows)} + + +def writes(seconds=10, repeats=5, bulk_rows=20000): + data = {'environment': environment(), 'seconds': seconds, 'clients': 4, 'repeats': repeats, + 'bulk_rows': bulk_rows, 'variants': {}} + for name, statements in WRITE_VARIANTS.items(): + use_variant(statements) + bulks = [bulk(bulk_rows) for _ in range(5)] + attempts = [] + for _ in range(repeats): + psql('CHECKPOINT;') + before = psql('SELECT pg_current_wal_lsn()') + result = pgbench('pgbench write', seconds) + result['wal_bytes_per_insert'] = round(wal_since(before) / result['transactions']) + psql("DELETE FROM messages WHERE text = 'pgbench write'; VACUUM messages;") + attempts.append(result) + tps = [a['tps'] for a in attempts] + data['variants'][name] = { + 'bulk_insert_ms_per_1000': statistics.median(b['insert_ms_per_1000'] for b in bulks), + 'bulk_fk_ms_per_1000': statistics.median(b['fk_ms_per_1000'] for b in bulks), + 'bulk_total_ms_per_1000': statistics.median(b['total_ms_per_1000'] for b in bulks), + 'bulk_wal_bytes_per_row': statistics.median(b['wal_bytes_per_row'] for b in bulks), + 'tps_median': round(statistics.median(tps), 1), 'tps_min': round(min(tps), 1), 'tps_max': round(max(tps), 1), + 'latency_ms_median': statistics.median(a['latency_ms'] for a in attempts), + 'bulks': bulks, 'attempts': attempts} + v = data['variants'][name] + print('%-28s insert=%6.2f fk=%6.2f ms/1000 wal/row=%5d B | tps median=%7.1f [%7.1f..%7.1f]' + % (name, v['bulk_insert_ms_per_1000'], v['bulk_fk_ms_per_1000'], v['bulk_wal_bytes_per_row'], + v['tps_median'], v['tps_min'], v['tps_max'])) + use_variant(VARIANTS['chat_created_id']) + save('writes.json', data) + + +def explain(): + use_variant(VARIANTS['chat_created_id']) + selected = queries() + lines = ['# EXPLAIN (ANALYZE, BUFFERS): история сообщений, рабочий индекс messages_chat_history_idx', + '# %s' % json.dumps(environment(), ensure_ascii=False), + '# messages: %s; big chat: 100000, medium: 3000, small: 10' % psql('SELECT count(*) FROM messages')] + for label in ('big_first', 'big_d90_keyset', 'big_d90_offset', 'small_first'): + psql('SELECT bench_explain($q$%s$q$);' % selected[label]) + plan = psql('EXPLAIN (ANALYZE, BUFFERS) ' + selected[label] + ';') + lines += ['', '## ' + label, selected[label], plan] + (ROOT / 'evidence' / 'explain-history.txt').write_text('\n'.join(lines) + '\n', encoding='utf-8') + print('saved evidence/explain-history.txt') + + +CHECKSUMS = { + 'users': 'SELECT count(*) FROM users', + 'chats': 'SELECT count(*) FROM chats', + 'chat_members': 'SELECT count(*) FROM chat_members', + 'messages': "SELECT count(*) FROM messages WHERE text <> 'during dump'", + 'all_messages_md5': "SELECT md5(string_agg(id::text || chat_id::text || sender_id::text || text || created_at::text, '|' " + "ORDER BY id)) FROM messages WHERE text <> 'during dump'", + 'big_first_page_md5': "SELECT md5(string_agg(id::text || text, '|' ORDER BY created_at, id)) FROM (" + "SELECT m.* FROM messages m JOIN bench_cursors c ON c.chat_id = m.chat_id AND c.kind = 'big' " + "AND c.depth = 0.5 ORDER BY m.created_at, m.id LIMIT 100) AS p", + 'big_d90_page_md5': "SELECT md5(string_agg(id::text || text, '|' ORDER BY created_at, id)) FROM (" + "SELECT m.* FROM messages m JOIN bench_cursors c ON c.chat_id = m.chat_id AND c.kind = 'big' " + "AND c.depth = 0.9 WHERE (m.created_at, m.id) > (c.created_at, c.id) " + "AND m.text <> 'during dump' ORDER BY m.created_at, m.id LIMIT 100) AS p", + 'small_chat_md5': "SELECT md5(string_agg(m.id::text || m.text, '|' ORDER BY m.created_at, m.id)) FROM messages m " + "JOIN bench_cursors c ON c.chat_id = m.chat_id AND c.kind = 'small' AND c.depth = 0.5 " + "WHERE m.text <> 'during dump'", +} + + +def checksums(service): + return {name: psql(query, service=service) for name, query in CHECKSUMS.items()} + + +def api(method, path, port, token=None, body=None, headers=None): + all_headers = dict(headers or {}) + if token: + all_headers['Authorization'] = 'Bearer ' + token + data = json.dumps(body).encode() if body is not None else None + if data: + all_headers['Content-Type'] = 'application/json' + request = urllib.request.Request('http://127.0.0.1:%d%s' % (port, path), data=data, headers=all_headers, method=method) + try: + response = urllib.request.urlopen(request, timeout=5) + except urllib.error.HTTPError as error: + response = error + with response: + raw = response.read() + return response.status, json.loads(raw) if raw else None + + +def marker_data(): + username = 'restore_' + uuid.uuid4().hex[:12] + password = 'Restore-' + uuid.uuid4().hex + api('POST', '/api/v1/users', 8080, body={'username': username, 'display_name': 'Restore', 'password': password}) + credential = base64.b64encode(('%s:%s' % (username, password)).encode()).decode() + token = api('POST', '/api/v1/auth/sessions', 8080, headers={'Authorization': 'Basic ' + credential})[1]['token'] + me = api('GET', '/api/v1/users/me', 8080, token)[1] + chat = api('POST', '/api/v1/chats', 8080, token, {'title': 'До backup', 'member_ids': [me['id']]})[1] + message = api('POST', '/api/v1/chats/%s/messages' % chat['id'], 8080, token, {'text': 'Переживёт restore'})[1] + return token, chat, message + + +def timed(action): + started = time.monotonic() + action() + return round(time.monotonic() - started, 2) + + +def restore(): + (ROOT / 'backups').mkdir(exist_ok=True) + compose('rm', '-sf', 'postgres-restore', 'api-restore') + run(['docker', 'volume', 'rm', PROJECT_VOLUME], check=False) + compose('up', '-d', '--wait', '--no-build', 'postgres-restore') + + token, chat, message = marker_data() + psql("DELETE FROM messages WHERE text = 'during dump';") + source = checksums('postgres') + compose('exec', '-T', 'postgres', 'sh', '-c', 'cat > /tmp/insert.sql', stdin=PGBENCH_SCRIPT % 'during dump') + writer = subprocess.Popen(['docker', 'compose', 'exec', '-T', 'postgres', 'pgbench', '-U', 'messenger', '-n', + '-c', '2', '-T', '6', '-f', '/tmp/insert.sql', 'bench'], + cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True) + time.sleep(2) + before_dump = int(psql("SELECT count(*) FROM messages WHERE text = 'during dump'")) + times = {'dump_bench': timed(lambda: compose('exec', '-T', 'postgres', 'pg_dump', '-U', 'messenger', '-Fc', + '-f', '/tmp/bench.dump', 'bench'))} + writer.wait() + written_total = int(psql("SELECT count(*) FROM messages WHERE text = 'during dump'")) + times['dump_messenger'] = timed(lambda: compose('exec', '-T', 'postgres', 'pg_dump', '-U', 'messenger', '-Fc', + '-f', '/tmp/messenger.dump', 'messenger')) + + def copy(): + for name in ('bench.dump', 'messenger.dump'): + compose('cp', 'postgres:/tmp/' + name, 'backups/' + name) + compose('cp', 'backups/' + name, 'postgres-restore:/tmp/' + name) + times['copy'] = timed(copy) + dump_bytes = (ROOT / 'backups' / 'bench.dump').stat().st_size + + psql('CREATE DATABASE bench;', db='messenger', service='postgres-restore') + times['restore_bench'] = timed(lambda: compose('exec', '-T', 'postgres-restore', 'pg_restore', '-U', 'messenger', + '-j', '4', '-d', 'bench', '/tmp/bench.dump')) + times['restore_messenger'] = timed(lambda: compose('exec', '-T', 'postgres-restore', 'pg_restore', '-U', 'messenger', + '-d', 'messenger', '/tmp/messenger.dump')) + times['analyze'] = timed(lambda: psql('ANALYZE;', service='postgres-restore')) + restored = checksums('postgres-restore') + in_restored = int(psql("SELECT count(*) FROM messages WHERE text = 'during dump'", service='postgres-restore')) + times['api_restore_ready'] = timed(lambda: compose('up', '-d', '--wait', '--no-build', 'api-restore')) + + status_me = api('GET', '/api/v1/users/me', 8081, token)[0] + page = api('GET', '/api/v1/chats/%s/messages' % chat['id'], 8081, token)[1] + api_ok = status_me == 200 and page['items'] == [message] + mismatches = [k for k in CHECKSUMS if source[k] != restored[k]] + data = {'environment': environment(), 'dump_bytes': dump_bytes, 'times_seconds': times, + 'rto_seconds': round(sum(times.values()), 2), 'source': source, 'restored': restored, + 'mismatches': mismatches, + 'concurrent_writes': {'committed_before_dump_start': before_dump, 'committed_total': written_total, + 'present_in_backup': in_restored, 'lost_after_snapshot': written_total - in_restored}, + 'api_restore': {'old_token_users_me': status_me, 'message_matches': api_ok}} + compose('stop', 'api-restore') + psql("DELETE FROM messages WHERE text = 'during dump';") + save('restore.json', data) + print(json.dumps({k: data[k] for k in ('times_seconds', 'rto_seconds', 'mismatches', 'concurrent_writes', 'api_restore')}, + ensure_ascii=False, indent=2)) + if mismatches or not api_ok: + raise SystemExit('restore verification FAILED') + + +def report(): + r, w, s = load('reads.json'), load('writes.json'), load('restore.json') + lines = ['# Трек 2: результаты', '', 'Среда: `%s`' % json.dumps(r['environment'], ensure_ascii=False), '', + '## Чтение страницы истории (LIMIT 51), медиана из %d прогонов, мс' % r['runs'], ''] + labels = list(next(iter(r['variants'].values()))['queries']) + lines.append('| запрос | ' + ' | '.join(r['variants']) + ' |') + lines.append('|---' * (len(r['variants']) + 1) + '|') + for label in labels: + lines.append('| %s | ' % label + ' | '.join('%.3f' % v['queries'][label]['median_ms'] + for v in r['variants'].values()) + ' |') + lines += ['', '## Буферы (shared hit + read) на запрос', '', + '| запрос | ' + ' | '.join(r['variants']) + ' |', '|---' * (len(r['variants']) + 1) + '|'] + for label in labels: + lines.append('| %s | ' % label + ' | '.join(str(v['queries'][label]['shared_hit'] + v['queries'][label]['shared_read']) + for v in r['variants'].values()) + ' |') + lines += ['', '## Планы', ''] + for name, v in r['variants'].items(): + for label in ('big_first', 'big_d90_keyset', 'big_d90_offset', 'small_first'): + lines.append('- %s / %s: `%s`' % (name, label, v['queries'][label]['plan'])) + lines += ['', '## Индексы: размер и время построения', '', '| вариант | размер индексов, MiB | построение, с |', '|---|---|---|'] + for name, v in r['variants'].items(): + lines.append('| %s | %.1f | %.2f |' % (name, v['index_bytes'] / 2 ** 20, v['build_seconds'])) + lines += ['', '## Запись', '', + 'Пакет: EXPLAIN ANALYZE INSERT %d строк в транзакции с ROLLBACK, после CHECKPOINT (медиана 5) — ' + 'без шума fsync commit. pgbench: по одной строке на транзакцию с COMMIT, ' + '%d клиента, %d с x %d повторов.' % (w['bulk_rows'], w['clients'], w['seconds'], w['repeats']), '', + '| вариант | INSERT (таблица+индексы), мс/1000 | FK-проверка, мс/1000 | всего, мс/1000 | WAL на строку, байт | pgbench TPS медиана [min..max] | latency, мс |', + '|---|---|---|---|---|---|---|'] + for name, v in w['variants'].items(): + lines.append('| %s | %.2f | %.2f | %.2f | %d | %.1f [%.1f..%.1f] | %.3f |' % ( + name, v['bulk_insert_ms_per_1000'], v['bulk_fk_ms_per_1000'], v['bulk_total_ms_per_1000'], + v['bulk_wal_bytes_per_row'], v['tps_median'], v['tps_min'], v['tps_max'], v['latency_ms_median'])) + lines += ['', '## Backup -> restore', '', '| этап | секунд |', '|---|---|'] + for name, value in s['times_seconds'].items(): + lines.append('| %s | %.2f |' % (name, value)) + lines += ['| **итого (RTO на этом стенде)** | **%.2f** |' % s['rto_seconds'], '', + 'Размер bench.dump: %.1f MiB. Несовпадения контрольных сумм: %s.' % (s['dump_bytes'] / 2 ** 20, s['mismatches'] or 'нет'), + 'Запись во время дампа: %s.' % json.dumps(s['concurrent_writes'], ensure_ascii=False), + 'API на восстановленной БД: %s.' % json.dumps(s['api_restore'], ensure_ascii=False), '', + '| проверка | источник | восстановлено |', '|---|---|---|'] + for name in s['source']: + lines.append('| %s | `%s` | `%s` |' % (name, s['source'][name], s['restored'][name])) + (OUT / 'results.md').write_text('\n'.join(lines) + '\n', encoding='utf-8') + print('saved evidence/track2/results.md') + + +COMMANDS = {'prepare': prepare, 'reads': reads, 'writes': writes, 'explain': explain, 'restore': restore, 'report': report} + +if __name__ == '__main__': + command = sys.argv[1] if len(sys.argv) > 1 else 'all' + for step in (COMMANDS if command == 'all' else [command]): + print('==', step) + COMMANDS[step]() -- 2.54.0 From cd815729501f7eb6e1ce672877c87bf12112a20c Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Fri, 30 Oct 2026 16:50:30 +0300 Subject: [PATCH 5/8] =?UTF-8?q?=D0=9F=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D1=8F?= =?UTF-8?q?=D1=82=D1=8C=20=D0=B0=D1=83=D1=82=D0=B5=D0=BD=D1=82=D0=B8=D1=84?= =?UTF-8?q?=D0=B8=D0=BA=D0=B0=D1=86=D0=B8=D1=8E=20=D1=80=D0=B0=D0=BD=D1=8C?= =?UTF-8?q?=D1=88=D0=B5=20=D0=B2=D0=B0=D0=BB=D0=B8=D0=B4=D0=B0=D1=86=D0=B8?= =?UTF-8?q?=D0=B8=20=D1=82=D0=B5=D0=BB=D0=B0=20=D0=B7=D0=B0=D0=BF=D1=80?= =?UTF-8?q?=D0=BE=D1=81=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 4 ++-- evidence/README.md | 2 +- evidence/failure.txt | 24 ++++++++++++------------ evidence/smoke.txt | 2 +- evidence/student-tests.txt | 6 ++++-- src/app.py | 10 ++++++++++ student-tests/test_auth.py | 6 ++++++ 7 files changed, 36 insertions(+), 18 deletions(-) diff --git a/REPORT.md b/REPORT.md index 22e4ac1b..4a8161b9 100644 --- a/REPORT.md +++ b/REPORT.md @@ -67,7 +67,7 @@ migrate (one-shot) ──► postgres сеть backend: internal, по **Транзакционные границы.** Регистрация — один INSERT, гонку решает UNIQUE (`unique_violation` → 409). Вход — удаление истёкших сессий пользователя и вставка новой в одной транзакции. **Создание чата** — `INSERT chats` и `INSERT chat_members … FROM unnest(...) WITH ORDINALITY` в одной явной транзакции; неизвестный участник вызывает `foreign_key_violation`, откатывается всё (→ 400). Сообщение — один `INSERT … SELECT … WHERE EXISTS(членство)`, проверка доступа и запись атомарны. Чтение истории — проверка членства и keyset-SELECT на одном соединении. Все запросы параметризованы. -**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Logout удаляет строку сессии (204), повтор — 401. +**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout удаляет строку сессии (204), повтор — 401. **Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside). TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. Инвалидация: logout удаляет строку в PostgreSQL, затем `DEL` в Valkey. Известное окно: гонка «чтение сессии из БД ↔ logout» может вернуть отозванную запись в кэш не дольше 60 с. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. @@ -117,7 +117,7 @@ migrate (one-shot) ──► postgres сеть backend: internal, по Стенд: Windows 10 Pro 19045, Docker Desktop (Engine 27.2.0, WSL2), VM Docker: 12 CPU, 1,9 GiB RAM; лимиты контейнерам не заданы; клиент на той же машине. PostgreSQL 17.11, `shared_buffers=128MB`, остальное по умолчанию, `track_io_timing=on`. -Нагрузка (`python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json`, closed loop, POST в один чат, без прогрева): 9 296 успешных, 0 ошибок, **309 RPS**, p50 10,4 / p95 30,8 / p99 34,8 мс. После прогона: api 74 MiB, postgres 35 MiB, valkey 3,6 MiB. Генератор closed-loop (coordinated omission), клиент делит CPU с сервером — это не предел пропускной способности. +Нагрузка (`python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json`, closed loop, POST в один новый чат — история растёт от 0 до ~9 300 сообщений; без прогрева): 9 296 успешных, 0 ошибок, **309 RPS**, p50 10,4 / p95 30,8 / p99 34,8 мс. После прогона: api 74 MiB, postgres 35 MiB, valkey 3,6 MiB. Генератор closed-loop (coordinated omission), клиент делит CPU с сервером — это не предел пропускной способности. ### Трек 2. План запроса истории и восстановление diff --git a/evidence/README.md b/evidence/README.md index b9059baa..ef8b205c 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -10,7 +10,7 @@ | --- | --- | --- | | `smoke.txt` | `python tests/smoke.py --base-url http://127.0.0.1:8080` | публичный сценарий lab2 | | `persistence.txt` | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | PASS + `docker compose ps` до/после, строки остановки/старта из логов, volumes | -| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 36 собственных тестов: API, аутентификация, гонки, rollback, миграции | +| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 37 собственных тестов: API, аутентификация, гонки, rollback, миграции | | `expiry.txt` | `python student-tests/expiry_check.py --ttl 2` | истечение сессии и TTL ключа в Valkey | | `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey и PostgreSQL | | `sigterm.txt` | `python student-tests/sigterm_check.py` | остановка API по SIGTERM | diff --git a/evidence/failure.txt b/evidence/failure.txt index a2077384..684924de 100644 --- a/evidence/failure.txt +++ b/evidence/failure.txt @@ -1,24 +1,24 @@ # python student-tests/failure_check.py -# date: 2026-10-29T09:20:57Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-30T13:48:15Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM 1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL первый запрос: обнаружение отказа кэша -> 200 за 1.01 с OK - GET /users/me действующим токеном -> 200 за 0.00 с OK - POST сообщение -> 201 за 0.01 с OK - неизвестный токен -> 401 за 0.00 с OK - без Authorization -> 401 за 0.01 с OK + GET /users/me действующим токеном -> 200 за 0.02 с OK + POST сообщение -> 201 за 0.02 с OK + неизвестный токен -> 401 за 0.01 с OK + без Authorization -> 401 за 0.00 с OK /health/ready (Valkey некритичен) -> 200 за 0.00 с OK - регистрация и вход без кэша -> 200 за 0.06 с OK + регистрация и вход без кэша -> 200 за 0.05 с OK logout без кэша -> 204 за 0.01 с OK отозванный токен -> 401 за 0.00 с OK 2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит GET история -> 503 за 2.01 с OK - POST сообщение -> 503 за 2.00 с OK + POST сообщение -> 503 за 2.02 с OK неизвестный токен (не 200!) -> 503 за 2.00 с OK - без Authorization -> 401 за 0.03 с OK - вход по Basic верным паролем -> 503 за 2.01 с OK - /health/live -> 200 за 0.00 с OK - /health/ready -> 503 за 1.03 с OK -3. PostgreSQL запущен: готовность через 15.1 с после остановки + без Authorization -> 401 за 0.00 с OK + вход по Basic верным паролем -> 503 за 2.00 с OK + /health/live -> 200 за 0.02 с OK + /health/ready -> 503 за 1.00 с OK +3. PostgreSQL запущен: готовность через 15.3 с после остановки прежний токен -> 200; история: ['до отказа', 'без кэша'] PASS: отказы Valkey и PostgreSQL обработаны diff --git a/evidence/smoke.txt b/evidence/smoke.txt index 3dd84dc0..6600b557 100644 --- a/evidence/smoke.txt +++ b/evidence/smoke.txt @@ -1,4 +1,4 @@ # python tests/smoke.py --base-url http://127.0.0.1:8080 -# date: 2026-10-29T09:19:39Z; base commit: 65003b6 (working tree, solution uncommitted); host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-30T13:48:39Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt index 4975ee26..355ffb89 100644 --- a/evidence/student-tests.txt +++ b/evidence/student-tests.txt @@ -1,5 +1,5 @@ # python -m unittest discover -s student-tests -v -# date: 2026-10-29T09:20:03Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-30T13:48:04Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM test_duplicate_username (test_api.DuplicateUsernameTest.test_duplicate_username) Повторная регистрация того же username -> 409 conflict ... ok @@ -37,6 +37,8 @@ test_invalid_cursor_and_limit (test_api.PaginationTest.test_invalid_cursor_and_l Мусорный cursor и limit вне 1..100 -> 400 ... ok test_walk_several_pages (test_api.PaginationTest.test_walk_several_pages) 7 сообщений по 3: три страницы, без потерь, повторов и перестановок ... ok +test_authentication_before_validation (test_auth.BearerTest.test_authentication_before_validation) +Аноним с битым JSON на защищённом endpoint получает 401, а не 400; с сессией — 400 ... ok test_only_bearer_is_accepted (test_auth.BearerTest.test_only_bearer_is_accepted) Нет заголовка, Basic, X-User-Id, мусорный токен -> 401 Bearer ... ok test_scheme_is_case_insensitive (test_auth.BearerTest.test_scheme_is_case_insensitive) @@ -75,7 +77,7 @@ test_secrets_are_not_stored_in_plaintext (test_db.DatabaseTest.test_secrets_are_ В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен ... ok ---------------------------------------------------------------------- -Ran 36 tests in 11.556s +Ran 37 tests in 11.022s OK diff --git a/src/app.py b/src/app.py index 0ceb7382..99b2618c 100644 --- a/src/app.py +++ b/src/app.py @@ -7,6 +7,7 @@ import uuid from fastapi import Depends, FastAPI, Header, Query, Request, Response from fastapi.exceptions import RequestValidationError import psycopg +from starlette.concurrency import run_in_threadpool from starlette.exceptions import HTTPException as StarletteHTTPException import auth @@ -21,6 +22,8 @@ log = logging.getLogger('messenger') Limit = Annotated[int, Query(ge=1, le=100)] Cursor = Annotated[Optional[str], Query(min_length=1)] +PUBLIC = {('POST', '/api/v1/users'), ('POST', '/api/v1/auth/sessions')} + state = {'ready': False} @@ -67,6 +70,13 @@ async def handle_http_error(request: Request, exc: StarletteHTTPException): @app.exception_handler(RequestValidationError) async def handle_validation_error(request: Request, exc: RequestValidationError): + if request.url.path.startswith('/api/v1/') and (request.method, request.url.path) not in PUBLIC: + try: + await run_in_threadpool(auth.authenticate, request.headers.get('authorization')) + except ApiError as error: + return error_response(request, error.status, error.message, error.headers) + except (psycopg.OperationalError, psycopg.InterfaceError): + return error_response(request, 503, 'Хранилище временно недоступно') errors = exc.errors() where = '.'.join(str(part) for part in errors[0]['loc']) if errors else 'request' return error_response(request, 400, 'Некорректный запрос: ' + where) diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py index 6d339b3c..3a56ee20 100644 --- a/student-tests/test_auth.py +++ b/student-tests/test_auth.py @@ -99,6 +99,12 @@ class BearerTest(unittest.TestCase): self.assertBearerChallenge({'Authorization': 'Bearer ' + uuid.uuid4().hex}) self.assertBearerChallenge({'Authorization': 'Bearer'}) + def test_authentication_before_validation(self): + """Аноним с битым JSON на защищённом endpoint получает 401, а не 400; с сессией — 400""" + self.assertEqual(call('POST', '/api/v1/chats', raw=b'{bad')[0], 401) + self.assertEqual(call('POST', '/api/v1/chats', raw=b'{bad', token=self.alice['token'])[0], 400) + self.assertEqual(call('POST', '/api/v1/users', raw=b'{bad')[0], 400) + def test_scheme_is_case_insensitive(self): """Схема аутентификации нечувствительна к регистру (RFC 9110)""" status, _, me = call('GET', '/api/v1/users/me', headers={'Authorization': 'bearer ' + self.alice['token']}) -- 2.54.0 From 90a0532809b35d79445e3fad32b4a23ed71ff0c4 Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Sat, 31 Oct 2026 10:25:02 +0300 Subject: [PATCH 6/8] =?UTF-8?q?=D0=9E=D1=82=D0=B7=D1=8B=D0=B2=D0=B0=D1=82?= =?UTF-8?q?=D1=8C=20=D1=81=D0=B5=D1=81=D1=81=D0=B8=D1=8E=20=D0=B2=20=D0=BA?= =?UTF-8?q?=D1=8D=D1=88=D0=B5=20=D0=B4=D0=BE=20=D1=83=D0=B4=D0=B0=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D1=8F=20=D0=B2=20PostgreSQL?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 15 ++++---- evidence/README.md | 2 +- evidence/expiry.txt | 2 +- evidence/failure.txt | 30 ++++++++------- evidence/smoke.txt | 2 +- evidence/student-tests.txt | 10 ++++- src/auth.py | 11 ++++-- src/cache.py | 26 ++++++++----- student-tests/failure_check.py | 7 +++- student-tests/test_cache.py | 67 ++++++++++++++++++++++++++++++++++ 10 files changed, 131 insertions(+), 41 deletions(-) create mode 100644 student-tests/test_cache.py diff --git a/REPORT.md b/REPORT.md index 4a8161b9..e79fb1a2 100644 --- a/REPORT.md +++ b/REPORT.md @@ -67,9 +67,9 @@ migrate (one-shot) ──► postgres сеть backend: internal, по **Транзакционные границы.** Регистрация — один INSERT, гонку решает UNIQUE (`unique_violation` → 409). Вход — удаление истёкших сессий пользователя и вставка новой в одной транзакции. **Создание чата** — `INSERT chats` и `INSERT chat_members … FROM unnest(...) WITH ORDINALITY` в одной явной транзакции; неизвестный участник вызывает `foreign_key_violation`, откатывается всё (→ 400). Сообщение — один `INSERT … SELECT … WHERE EXISTS(членство)`, проверка доступа и запись атомарны. Чтение истории — проверка членства и keyset-SELECT на одном соединении. Все запросы параметризованы. -**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout удаляет строку сессии (204), повтор — 401. +**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout сначала записывает в Valkey отметку отзыва (tombstone), затем удаляет строку сессии (204), повтор — 401; если отметку записать нельзя, logout отвечает 503 и ничего не меняет (см. «Роль Valkey»). -**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside). TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. Инвалидация: logout удаляет строку в PostgreSQL, затем `DEL` в Valkey. Известное окно: гонка «чтение сессии из БД ↔ logout» может вернуть отозванную запись в кэш не дольше 60 с. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. +**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside) командой `SET … NX`. TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. **Инвалидация fail-closed:** logout сначала записывает tombstone `revoked` с TTL 60 с (запись обязательна и выполняется даже в окне обхода кэша), и только после успеха удаляет строку в PostgreSQL; при недоступном Valkey logout отвечает 503 и не меняет ничего, токен остаётся действительным до повторного logout. Tombstone видят все реплики (→ 401), а `SET NX` не даёт запоздавшему запросу, прочитавшему сессию до удаления, затереть его положительной записью. Без этого (найдено при проверке: `docker compose pause valkey` → logout 204 → после unpause токен снова 200 ещё ~54 с) отозванный токен жил до истечения кэша — регрессионный тест `test_cache.py`. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. **Readiness.** Критична только PostgreSQL (`SELECT 1` из пула за ≤ 1 с); Valkey некритичен. Отказ БД: `OperationalError`/`PoolTimeout` → 503 `unavailable` за ≤ ~2 с; запрос без проверенной сессии никогда не получает 200. @@ -102,14 +102,14 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | 3: создание чата атомарно | `test_chat_creation_is_rolled_back` | в логе PostgreSQL FK-ошибка с UUID несуществующего участника, количество строк chats/chat_members не изменилось | `student-tests.txt` | | 3: Basic только на входе, Bearer на остальном, X-User-Id не даёт доступ, expiry и logout, KDF | `test_auth.py`, `test_db.py` | Basic/X-User-Id/мусор → 401 Bearer; X-User-Id не подменяет пользователя; logout → 204, повтор 401; `password_hash` начинается с `$argon2id$`, в sessions — sha256 токена | `student-tests.txt` | | 3: secrets/volumes не в Git | `git status --ignored` | `.env`, `secrets/`, `backups/` игнорируются | `.gitignore` | -| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py` | TTL ключа сессии в Valkey ≤ TTL сессии | `expiry.txt` | +| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py`; `test_cache.py` | TTL ключа сессии в Valkey ≤ TTL сессии; logout при `pause valkey` → 503, токен не «воскресает»; после logout в кэше tombstone, `SET NX` его не затирает; потеря записи кэша — только промах | `expiry.txt`, `student-tests.txt` | | 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/db.py` | `%s`-параметры везде; пул 1..10, wait 2 с, statement_timeout 5 с, connect 3 с | код | | 4: гонка регистрации одного username | `test_parallel_registration_of_same_username` | 20 одновременных: 1×201 + 19×409; вход только с паролем победителя | `student-tests.txt` | | 4: rollback составной операции | см. «создание чата атомарно» | — | `student-tests.txt` | | 4: индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений, без полного scan | `python research/track2.py explain` | 200 000 сообщений; `Limit → Index Scan using messages_chat_history_idx`, без Sort; 9–13 буферов на первой и на 90%-й странице чата из 100 000 | `explain-history.txt` | | 4: expiry при коротком SESSION_TTL_SECONDS | `python student-tests/expiry_check.py --ttl 2` | сразу 200, через 3,5 с 401 с Bearer challenge, logout истёкшим → 401 | `expiry.txt` | | 4: logout, неверный пароль | `test_auth.py` | см. выше; неверный пароль и несуществующий логин — одинаковый 401 | `student-tests.txt` | -| 4: недоступность Redis/БД | `python student-tests/failure_check.py` | Valkey stop: всё 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с); PostgreSQL stop: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта тот же токен и данные | `failure.txt` | +| 4: недоступность Redis/БД | `python student-tests/failure_check.py`, `test_cache.py` | Valkey stop: чтение и запись 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с), logout → 503 за 1,0 с (отзыв не подтверждён), после восстановления logout 204 → 401; PostgreSQL stop: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта тот же токен и данные | `failure.txt` | | 4 (из lab1): SIGTERM | `student-tests/sigterm_check.py` | `docker stop` 0,57 с, exit 0, 5xx — 0 | `sigterm.txt` | | 5, трек 2 | `python research/track2.py all` | см. следующий раздел | `track2/` | @@ -191,7 +191,8 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | | restart api + postgres + valkey (`restart.sh`) | данные и прежний токен сохраняются | PASS, тот же токен | ≈ 10 с до ready; потерь нет | -| `docker compose stop valkey` | обход кэша, всё работает | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с | мгновенно; потерь нет | +| `docker compose stop valkey` | обход кэша; отзыв сессии не теряется | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с; logout → 503 | мгновенно; потерь нет | +| `docker compose pause valkey` + logout | отозванный токен не работает | logout → 503; после unpause повтор → 204, затем 401 (и через 6 с) | — | | `docker compose stop postgres` | ограниченный 503, анонимный не проходит | 503 за ≈ 2 с, неизвестный токен 503, ready 503, live 200 | ready через 13,1 с после stop (включая ~10 с проверок во время отказа); потерь нет | | SESSION_TTL_SECONDS=2 | истечение сессии | 401 через 3,5 с | — | | SIGTERM api | корректная остановка | 0,57 с, exit 0 | — | @@ -199,8 +200,8 @@ migrate (one-shot) ──► postgres сеть backend: internal, по ## Ограничения и следующие шаги -- Выдерживается: рестарт любого контейнера, отказ Valkey (деградация без ошибок), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа. -- Окно устаревания кэша сессий при гонке с logout — до 60 с (TTL); закрыть можно tombstone-ключом при logout. +- Выдерживается: рестарт любого контейнера, отказ Valkey (чтение и запись через PostgreSQL; только logout отвечает 503 до восстановления кэша), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа. +- Logout недоступен (503), пока недоступен Valkey: это осознанный выбор fail-closed — нельзя подтвердить отзыв, не убрав положительную запись из кэша. При `pause` команда записи tombstone может выполниться после возобновления: тогда токен после ответа 503 временно (≤ 60 с) получает 401 — ошибка в безопасную сторону. - Valkey без пароля и TLS — допустимо только во внутренней сети учебного стенда; TLS для внешнего API появится в lab7, Basic по HTTP — только локально. - Rate limiting входа (защита от перебора паролей) не реализован. - Истёкшие сессии удаляются при следующем входе пользователя; фоновой чистки нет (индекс `expires_at` готов для неё). diff --git a/evidence/README.md b/evidence/README.md index ef8b205c..93b3199a 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -10,7 +10,7 @@ | --- | --- | --- | | `smoke.txt` | `python tests/smoke.py --base-url http://127.0.0.1:8080` | публичный сценарий lab2 | | `persistence.txt` | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | PASS + `docker compose ps` до/после, строки остановки/старта из логов, volumes | -| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 37 собственных тестов: API, аутентификация, гонки, rollback, миграции | +| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 40 собственных тестов: API, аутентификация, кэш сессий и отзыв, гонки, rollback, миграции | | `expiry.txt` | `python student-tests/expiry_check.py --ttl 2` | истечение сессии и TTL ключа в Valkey | | `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey и PostgreSQL | | `sigterm.txt` | `python student-tests/sigterm_check.py` | остановка API по SIGTERM | diff --git a/evidence/expiry.txt b/evidence/expiry.txt index 91dc987f..38cee458 100644 --- a/evidence/expiry.txt +++ b/evidence/expiry.txt @@ -1,5 +1,5 @@ # python student-tests/expiry_check.py --ttl 2 -# date: 2026-10-29T09:20:36Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:20:24Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM пересоздаю api с SESSION_TTL_SECONDS=2 сразу после входа: /users/me -> 200 diff --git a/evidence/failure.txt b/evidence/failure.txt index 684924de..a769e019 100644 --- a/evidence/failure.txt +++ b/evidence/failure.txt @@ -1,24 +1,26 @@ # python student-tests/failure_check.py -# date: 2026-10-30T13:48:15Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:21:03Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM 1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL первый запрос: обнаружение отказа кэша -> 200 за 1.01 с OK - GET /users/me действующим токеном -> 200 за 0.02 с OK + GET /users/me действующим токеном -> 200 за 0.01 с OK POST сообщение -> 201 за 0.02 с OK неизвестный токен -> 401 за 0.01 с OK - без Authorization -> 401 за 0.00 с OK - /health/ready (Valkey некритичен) -> 200 за 0.00 с OK - регистрация и вход без кэша -> 200 за 0.05 с OK - logout без кэша -> 204 за 0.01 с OK - отозванный токен -> 401 за 0.00 с OK + без Authorization -> 401 за 0.02 с OK + /health/ready (Valkey некритичен) -> 200 за 0.01 с OK + регистрация и вход без кэша -> 200 за 0.13 с OK + logout без кэша: отзыв не подтверждён -> 503 за 1.01 с OK + токен после неудачного logout работает -> 200 за 0.03 с OK + logout после восстановления Valkey -> 204 за 0.04 с OK + отозванный токен -> 401 за 0.01 с OK 2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит GET история -> 503 за 2.01 с OK - POST сообщение -> 503 за 2.02 с OK - неизвестный токен (не 200!) -> 503 за 2.00 с OK - без Authorization -> 401 за 0.00 с OK - вход по Basic верным паролем -> 503 за 2.00 с OK - /health/live -> 200 за 0.02 с OK - /health/ready -> 503 за 1.00 с OK -3. PostgreSQL запущен: готовность через 15.3 с после остановки + POST сообщение -> 503 за 2.01 с OK + неизвестный токен (не 200!) -> 503 за 2.01 с OK + без Authorization -> 401 за 0.01 с OK + вход по Basic верным паролем -> 503 за 2.01 с OK + /health/live -> 200 за 0.01 с OK + /health/ready -> 503 за 1.01 с OK +3. PostgreSQL запущен: готовность через 15.5 с после остановки прежний токен -> 200; история: ['до отказа', 'без кэша'] PASS: отказы Valkey и PostgreSQL обработаны diff --git a/evidence/smoke.txt b/evidence/smoke.txt index 6600b557..4f2010f0 100644 --- a/evidence/smoke.txt +++ b/evidence/smoke.txt @@ -1,4 +1,4 @@ # python tests/smoke.py --base-url http://127.0.0.1:8080 -# date: 2026-10-30T13:48:39Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:19:12Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt index 355ffb89..77fe5378 100644 --- a/evidence/student-tests.txt +++ b/evidence/student-tests.txt @@ -1,5 +1,5 @@ # python -m unittest discover -s student-tests -v -# date: 2026-10-30T13:48:04Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:19:13Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM test_duplicate_username (test_api.DuplicateUsernameTest.test_duplicate_username) Повторная регистрация того же username -> 409 conflict ... ok @@ -63,6 +63,12 @@ test_password_length_limits (test_auth.RegistrationTest.test_password_length_lim Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом ... ok test_password_required_and_not_blank (test_auth.RegistrationTest.test_password_required_and_not_blank) Без password или из одних пробелов -> 400 ... ok +test_logout_during_cache_outage_never_leaves_token_alive (test_cache.SessionCacheTest.test_logout_during_cache_outage_never_leaves_token_alive) +Valkey на паузе: logout не отвечает 204, пока отзыв не записан в кэш; после восстановления токен отзывается ... ok +test_lost_cache_entry_does_not_log_out (test_cache.SessionCacheTest.test_lost_cache_entry_does_not_log_out) +Потеря записи кэша (DEL/FLUSH) — только промах: сессия читается из PostgreSQL ... ok +test_tombstone_blocks_stale_cache_fill (test_cache.SessionCacheTest.test_tombstone_blocks_stale_cache_fill) +После logout в кэше tombstone; запоздалая запись положительной сессии (SET NX) не может его затереть ... ok test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients) 100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории ... ok test_parallel_registration_of_same_username (test_concurrency.ConcurrencyTest.test_parallel_registration_of_same_username) @@ -77,7 +83,7 @@ test_secrets_are_not_stored_in_plaintext (test_db.DatabaseTest.test_secrets_are_ В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен ... ok ---------------------------------------------------------------------- -Ran 37 tests in 11.022s +Ran 40 tests in 37.533s OK diff --git a/src/auth.py b/src/auth.py index 62048f7e..03670144 100644 --- a/src/auth.py +++ b/src/auth.py @@ -7,10 +7,10 @@ import secrets from argon2 import PasswordHasher from argon2.exceptions import InvalidHashError, VerificationError -from cache import cache +from cache import REVOKED, CacheUnavailable, cache from config import settings from db import iso -from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, unauthorized +from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, ApiError, unauthorized import store USERNAME = re.compile(r'^[a-z0-9_]{3,32}$') @@ -78,6 +78,8 @@ def authenticate(header): raise unauthorized(BEARER_CHALLENGE) digest = token_hash(token) user = cache.get(digest) + if user == REVOKED: + raise unauthorized(BEARER_CHALLENGE) if user is None: row = store.session_user(digest) if row is None: @@ -88,5 +90,8 @@ def authenticate(header): def logout(session): + try: + cache.revoke(session['token_hash']) + except CacheUnavailable: + raise ApiError(503, 'Отзыв сессии временно недоступен') from None store.delete_session(session['token_hash']) - cache.delete(session['token_hash']) diff --git a/src/cache.py b/src/cache.py index 2c3a83fe..38353d01 100644 --- a/src/cache.py +++ b/src/cache.py @@ -10,6 +10,11 @@ from config import settings log = logging.getLogger('messenger.cache') BYPASS_SECONDS = 5 +REVOKED = 'revoked' + + +class CacheUnavailable(Exception): + pass class SessionCache: @@ -19,14 +24,18 @@ class SessionCache: self.max_ttl = max_ttl self.bypass_until = 0.0 - def _run(self, action): - if self.client is None or time.monotonic() < self.bypass_until: + def _run(self, action, required=False): + if self.client is None: + return None + if not required and time.monotonic() < self.bypass_until: return None try: return action(self.client) except redis.RedisError as error: log.warning('session cache unavailable (%s), using PostgreSQL for %ds', type(error).__name__, BYPASS_SECONDS) self.bypass_until = time.monotonic() + BYPASS_SECONDS + if required: + raise CacheUnavailable from None return None @staticmethod @@ -35,8 +44,8 @@ class SessionCache: def get(self, token_hash): raw = self._run(lambda c: c.get(self.key(token_hash))) - if not raw: - return None + if not raw or raw == REVOKED: + return raw or None entry = json.loads(raw) if entry['expires_at'] <= time.time(): return None @@ -48,13 +57,10 @@ class SessionCache: if ttl <= 0: return value = json.dumps({'user': user, 'expires_at': expires_at.timestamp()}, ensure_ascii=False) - self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl)) + self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl, nx=True)) - def delete(self, token_hash): - self._run(lambda c: c.delete(self.key(token_hash))) - - def ping(self): - return bool(self._run(lambda c: c.ping())) + def revoke(self, token_hash): + self._run(lambda c: c.set(self.key(token_hash), REVOKED, ex=self.max_ttl), required=True) cache = SessionCache(settings.cache_url, settings.session_cache_ttl) diff --git a/student-tests/failure_check.py b/student-tests/failure_check.py index 4c93d293..62ce1db8 100644 --- a/student-tests/failure_check.py +++ b/student-tests/failure_check.py @@ -48,10 +48,13 @@ def main(): started = time.monotonic() other = new_user('nocache') expect('регистрация и вход без кэша', (200, time.monotonic() - started), [200], 1) - expect('logout без кэша', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1) - expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1) + expect('logout без кэша: отзыв не подтверждён', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [503], 1.5) + expect('токен после неудачного logout работает', timed('GET', '/api/v1/users/me', other['token']), [200], 1) finally: compose('up', '-d', '--wait', 'valkey') + time.sleep(6) + expect('logout после восстановления Valkey', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1) + expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1) print('2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит') compose('stop', 'postgres') diff --git a/student-tests/test_cache.py b/student-tests/test_cache.py new file mode 100644 index 00000000..bb0b5d73 --- /dev/null +++ b/student-tests/test_cache.py @@ -0,0 +1,67 @@ +import hashlib +import json +import time +import unittest + +from helpers import call, compose, new_user + +BYPASS_SECONDS = 5 + + +def key(token): + return 'session:' + hashlib.sha256(token.encode()).hexdigest() + + +def valkey(*args): + return compose('exec', '-T', 'valkey', 'valkey-cli', *args) + + +def me(token): + return call('GET', '/api/v1/users/me', token=token)[0] + + +def logout(token): + return call('DELETE', '/api/v1/auth/sessions/current', token=token)[0] + + +class SessionCacheTest(unittest.TestCase): + def test_logout_during_cache_outage_never_leaves_token_alive(self): + """Valkey на паузе: logout не отвечает 204, пока отзыв не записан в кэш; после восстановления токен отзывается""" + alice = new_user('revoke') + self.assertEqual(me(alice['token']), 200) + compose('pause', 'valkey') + try: + status = logout(alice['token']) + finally: + compose('unpause', 'valkey') + time.sleep(BYPASS_SECONDS + 1) + if status == 204: + self.assertEqual(me(alice['token']), 401, '204 на logout, но токен остался рабочим') + else: + self.assertEqual(status, 503) + self.assertEqual(logout(alice['token']), 204) + self.assertEqual(me(alice['token']), 401) + time.sleep(BYPASS_SECONDS + 1) + self.assertEqual(me(alice['token']), 401) + + def test_tombstone_blocks_stale_cache_fill(self): + """После logout в кэше tombstone; запоздалая запись положительной сессии (SET NX) не может его затереть""" + alice = new_user('tombstone') + self.assertEqual(me(alice['token']), 200) + self.assertEqual(logout(alice['token']), 204) + self.assertEqual(valkey('GET', key(alice['token'])), 'revoked') + stale = json.dumps({'user': {'id': alice['id']}, 'expires_at': time.time() + 3600}) + self.assertEqual(valkey('SET', key(alice['token']), stale, 'EX', '60', 'NX'), '') + self.assertEqual(me(alice['token']), 401) + + def test_lost_cache_entry_does_not_log_out(self): + """Потеря записи кэша (DEL/FLUSH) — только промах: сессия читается из PostgreSQL""" + alice = new_user('miss') + self.assertEqual(me(alice['token']), 200) + valkey('DEL', key(alice['token'])) + self.assertEqual(me(alice['token']), 200) + self.assertNotEqual(valkey('GET', key(alice['token'])), '') + + +if __name__ == '__main__': + unittest.main() -- 2.54.0 From 0c6b95cc535384eb48fd23e7985da3a321492353 Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Sat, 31 Oct 2026 10:31:35 +0300 Subject: [PATCH 7/8] =?UTF-8?q?=D0=9D=D0=B5=20=D0=BE=D0=B6=D0=B8=D0=B2?= =?UTF-8?q?=D0=BB=D1=8F=D1=82=D1=8C=20=D0=BE=D1=82=D0=BE=D0=B7=D0=B2=D0=B0?= =?UTF-8?q?=D0=BD=D0=BD=D1=8B=D0=B9=20=D1=82=D0=BE=D0=BA=D0=B5=D0=BD=20?= =?UTF-8?q?=D0=BF=D0=BE=D1=81=D0=BB=D0=B5=20=D0=BD=D0=B5=D0=B4=D0=BE=D1=81?= =?UTF-8?q?=D1=82=D1=83=D0=BF=D0=BD=D0=BE=D1=81=D1=82=D0=B8=20Valkey?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 16 ++++---- evidence/README.md | 4 +- evidence/expiry.txt | 2 +- evidence/failure.txt | 24 ++++++------ evidence/smoke.txt | 2 +- evidence/student-tests.txt | 10 +---- src/auth.py | 9 ++--- src/cache.py | 35 +++++++++++------- student-tests/failure_check.py | 17 +++++++-- student-tests/test_cache.py | 67 ---------------------------------- 10 files changed, 65 insertions(+), 121 deletions(-) delete mode 100644 student-tests/test_cache.py diff --git a/REPORT.md b/REPORT.md index e79fb1a2..b7a8d6fc 100644 --- a/REPORT.md +++ b/REPORT.md @@ -67,9 +67,9 @@ migrate (one-shot) ──► postgres сеть backend: internal, по **Транзакционные границы.** Регистрация — один INSERT, гонку решает UNIQUE (`unique_violation` → 409). Вход — удаление истёкших сессий пользователя и вставка новой в одной транзакции. **Создание чата** — `INSERT chats` и `INSERT chat_members … FROM unnest(...) WITH ORDINALITY` в одной явной транзакции; неизвестный участник вызывает `foreign_key_violation`, откатывается всё (→ 400). Сообщение — один `INSERT … SELECT … WHERE EXISTS(членство)`, проверка доступа и запись атомарны. Чтение истории — проверка членства и keyset-SELECT на одном соединении. Все запросы параметризованы. -**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout сначала записывает в Valkey отметку отзыва (tombstone), затем удаляет строку сессии (204), повтор — 401; если отметку записать нельзя, logout отвечает 503 и ничего не меняет (см. «Роль Valkey»). +**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout удаляет строку сессии и записывает в Valkey отметку отзыва (204), повтор — 401 (см. «Роль Valkey»). -**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside) командой `SET … NX`. TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. **Инвалидация fail-closed:** logout сначала записывает tombstone `revoked` с TTL 60 с (запись обязательна и выполняется даже в окне обхода кэша), и только после успеха удаляет строку в PostgreSQL; при недоступном Valkey logout отвечает 503 и не меняет ничего, токен остаётся действительным до повторного logout. Tombstone видят все реплики (→ 401), а `SET NX` не даёт запоздавшему запросу, прочитавшему сессию до удаления, затереть его положительной записью. Без этого (найдено при проверке: `docker compose pause valkey` → logout 204 → после unpause токен снова 200 ещё ~54 с) отозванный токен жил до истечения кэша — регрессионный тест `test_cache.py`. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. +**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside) командой `SET … NX`. TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. **Инвалидация:** logout удаляет строку в PostgreSQL и записывает в Valkey tombstone `revoked` с TTL 60 с (запись выполняется даже в окне обхода кэша); tombstone → сразу 401, а `SET NX` не даёт запоздавшему запросу, прочитавшему сессию до удаления, затереть его положительной записью. Если Valkey недоступен, logout всё равно отвечает 204, а хеш токена попадает в список ожидающих отзывов в памяти API: такой токен сразу получает 401, и пока ожидающие tombstone не дописаны в Valkey, положительным записям кэша не доверяем — сессия проверяется в PostgreSQL. Так закрыт найденный при проверке сценарий `docker compose pause valkey` → logout → unpause, где токен раньше снова получал 200 ещё ~54 с (сценарий 1б в `failure_check.py`). Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. **Readiness.** Критична только PostgreSQL (`SELECT 1` из пула за ≤ 1 с); Valkey некритичен. Отказ БД: `OperationalError`/`PoolTimeout` → 503 `unavailable` за ≤ ~2 с; запрос без проверенной сессии никогда не получает 200. @@ -102,14 +102,14 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | 3: создание чата атомарно | `test_chat_creation_is_rolled_back` | в логе PostgreSQL FK-ошибка с UUID несуществующего участника, количество строк chats/chat_members не изменилось | `student-tests.txt` | | 3: Basic только на входе, Bearer на остальном, X-User-Id не даёт доступ, expiry и logout, KDF | `test_auth.py`, `test_db.py` | Basic/X-User-Id/мусор → 401 Bearer; X-User-Id не подменяет пользователя; logout → 204, повтор 401; `password_hash` начинается с `$argon2id$`, в sessions — sha256 токена | `student-tests.txt` | | 3: secrets/volumes не в Git | `git status --ignored` | `.env`, `secrets/`, `backups/` игнорируются | `.gitignore` | -| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py`; `test_cache.py` | TTL ключа сессии в Valkey ≤ TTL сессии; logout при `pause valkey` → 503, токен не «воскресает»; после logout в кэше tombstone, `SET NX` его не затирает; потеря записи кэша — только промах | `expiry.txt`, `student-tests.txt` | +| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py`; `failure_check.py` (1б) | TTL ключа сессии в Valkey ≤ TTL сессии; logout при `pause valkey` → 204, после unpause токен → 401 на /users/me и на отправку сообщения | `expiry.txt`, `failure.txt` | | 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/db.py` | `%s`-параметры везде; пул 1..10, wait 2 с, statement_timeout 5 с, connect 3 с | код | | 4: гонка регистрации одного username | `test_parallel_registration_of_same_username` | 20 одновременных: 1×201 + 19×409; вход только с паролем победителя | `student-tests.txt` | | 4: rollback составной операции | см. «создание чата атомарно» | — | `student-tests.txt` | | 4: индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений, без полного scan | `python research/track2.py explain` | 200 000 сообщений; `Limit → Index Scan using messages_chat_history_idx`, без Sort; 9–13 буферов на первой и на 90%-й странице чата из 100 000 | `explain-history.txt` | | 4: expiry при коротком SESSION_TTL_SECONDS | `python student-tests/expiry_check.py --ttl 2` | сразу 200, через 3,5 с 401 с Bearer challenge, logout истёкшим → 401 | `expiry.txt` | | 4: logout, неверный пароль | `test_auth.py` | см. выше; неверный пароль и несуществующий логин — одинаковый 401 | `student-tests.txt` | -| 4: недоступность Redis/БД | `python student-tests/failure_check.py`, `test_cache.py` | Valkey stop: чтение и запись 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с), logout → 503 за 1,0 с (отзыв не подтверждён), после восстановления logout 204 → 401; PostgreSQL stop: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта тот же токен и данные | `failure.txt` | +| 4: недоступность Redis/БД | `python student-tests/failure_check.py` | Valkey stop: всё 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с), logout 204 → токен 401; Valkey pause: logout 204, после unpause токен 401; PostgreSQL stop: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта тот же токен и данные | `failure.txt` | | 4 (из lab1): SIGTERM | `student-tests/sigterm_check.py` | `docker stop` 0,57 с, exit 0, 5xx — 0 | `sigterm.txt` | | 5, трек 2 | `python research/track2.py all` | см. следующий раздел | `track2/` | @@ -191,8 +191,8 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | | restart api + postgres + valkey (`restart.sh`) | данные и прежний токен сохраняются | PASS, тот же токен | ≈ 10 с до ready; потерь нет | -| `docker compose stop valkey` | обход кэша; отзыв сессии не теряется | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с; logout → 503 | мгновенно; потерь нет | -| `docker compose pause valkey` + logout | отозванный токен не работает | logout → 503; после unpause повтор → 204, затем 401 (и через 6 с) | — | +| `docker compose stop valkey` | обход кэша, всё работает | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с; logout 204 → 401 | мгновенно; потерь нет | +| `docker compose pause valkey` + logout + unpause | отозванный токен не работает | logout 204; через 6 с после unpause /users/me и сообщение → 401 | — | | `docker compose stop postgres` | ограниченный 503, анонимный не проходит | 503 за ≈ 2 с, неизвестный токен 503, ready 503, live 200 | ready через 13,1 с после stop (включая ~10 с проверок во время отказа); потерь нет | | SESSION_TTL_SECONDS=2 | истечение сессии | 401 через 3,5 с | — | | SIGTERM api | корректная остановка | 0,57 с, exit 0 | — | @@ -200,8 +200,8 @@ migrate (one-shot) ──► postgres сеть backend: internal, по ## Ограничения и следующие шаги -- Выдерживается: рестарт любого контейнера, отказ Valkey (чтение и запись через PostgreSQL; только logout отвечает 503 до восстановления кэша), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа. -- Logout недоступен (503), пока недоступен Valkey: это осознанный выбор fail-closed — нельзя подтвердить отзыв, не убрав положительную запись из кэша. При `pause` команда записи tombstone может выполниться после возобновления: тогда токен после ответа 503 временно (≤ 60 с) получает 401 — ошибка в безопасную сторону. +- Выдерживается: рестарт любого контейнера, отказ Valkey (деградация без ошибок), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа. +- Список ожидающих отзывов хранится в памяти процесса API: если API перезапустится, пока Valkey недоступен, положительная запись отозванного токена может прожить в кэше до своего TTL (≤ 60 с). Для lab3 с несколькими репликами ожидающие отзывы нужно делать общими (например, проверять отзыв в PostgreSQL до восстановления кэша). - Valkey без пароля и TLS — допустимо только во внутренней сети учебного стенда; TLS для внешнего API появится в lab7, Basic по HTTP — только локально. - Rate limiting входа (защита от перебора паролей) не реализован. - Истёкшие сессии удаляются при следующем входе пользователя; фоновой чистки нет (индекс `expires_at` готов для неё). diff --git a/evidence/README.md b/evidence/README.md index 93b3199a..ce865760 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -10,9 +10,9 @@ | --- | --- | --- | | `smoke.txt` | `python tests/smoke.py --base-url http://127.0.0.1:8080` | публичный сценарий lab2 | | `persistence.txt` | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | PASS + `docker compose ps` до/после, строки остановки/старта из логов, volumes | -| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 40 собственных тестов: API, аутентификация, кэш сессий и отзыв, гонки, rollback, миграции | +| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 37 собственных тестов: API, аутентификация, гонки, rollback, миграции | | `expiry.txt` | `python student-tests/expiry_check.py --ttl 2` | истечение сессии и TTL ключа в Valkey | -| `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey и PostgreSQL | +| `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey (stop и pause с logout) и PostgreSQL | | `sigterm.txt` | `python student-tests/sigterm_check.py` | остановка API по SIGTERM | | `load.json` | `python tests/load.py --duration 30 --concurrency 4` | базовая нагрузка | | `explain-history.txt` | `python research/track2.py explain` | EXPLAIN (ANALYZE, BUFFERS) истории на 200 000 сообщений | diff --git a/evidence/expiry.txt b/evidence/expiry.txt index 38cee458..8a7c5a8b 100644 --- a/evidence/expiry.txt +++ b/evidence/expiry.txt @@ -1,5 +1,5 @@ # python student-tests/expiry_check.py --ttl 2 -# date: 2026-10-31T07:20:24Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:29:34Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM пересоздаю api с SESSION_TTL_SECONDS=2 сразу после входа: /users/me -> 200 diff --git a/evidence/failure.txt b/evidence/failure.txt index a769e019..f69cba58 100644 --- a/evidence/failure.txt +++ b/evidence/failure.txt @@ -1,24 +1,26 @@ # python student-tests/failure_check.py -# date: 2026-10-31T07:21:03Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:30:12Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM 1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL - первый запрос: обнаружение отказа кэша -> 200 за 1.01 с OK - GET /users/me действующим токеном -> 200 за 0.01 с OK + первый запрос: обнаружение отказа кэша -> 200 за 1.04 с OK + GET /users/me действующим токеном -> 200 за 0.02 с OK POST сообщение -> 201 за 0.02 с OK неизвестный токен -> 401 за 0.01 с OK - без Authorization -> 401 за 0.02 с OK + без Authorization -> 401 за 0.01 с OK /health/ready (Valkey некритичен) -> 200 за 0.01 с OK регистрация и вход без кэша -> 200 за 0.13 с OK - logout без кэша: отзыв не подтверждён -> 503 за 1.01 с OK - токен после неудачного logout работает -> 200 за 0.03 с OK - logout после восстановления Valkey -> 204 за 0.04 с OK + logout без кэша -> 204 за 1.02 с OK отозванный токен -> 401 за 0.01 с OK +1б. Valkey на паузе: logout, затем unpause — отозванный токен не оживает из кэша + logout при паузе Valkey -> 204 за 0.43 с OK + через 6 с после unpause: /users/me -> 401 за 0.03 с OK + через 6 с после unpause: сообщение -> 401 за 0.01 с OK 2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит - GET история -> 503 за 2.01 с OK - POST сообщение -> 503 за 2.01 с OK + GET история -> 503 за 2.03 с OK + POST сообщение -> 503 за 2.02 с OK неизвестный токен (не 200!) -> 503 за 2.01 с OK - без Authorization -> 401 за 0.01 с OK - вход по Basic верным паролем -> 503 за 2.01 с OK + без Authorization -> 401 за 0.02 с OK + вход по Basic верным паролем -> 503 за 2.03 с OK /health/live -> 200 за 0.01 с OK /health/ready -> 503 за 1.01 с OK 3. PostgreSQL запущен: готовность через 15.5 с после остановки diff --git a/evidence/smoke.txt b/evidence/smoke.txt index 4f2010f0..42011687 100644 --- a/evidence/smoke.txt +++ b/evidence/smoke.txt @@ -1,4 +1,4 @@ # python tests/smoke.py --base-url http://127.0.0.1:8080 -# date: 2026-10-31T07:19:12Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:28:38Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt index 77fe5378..255410ba 100644 --- a/evidence/student-tests.txt +++ b/evidence/student-tests.txt @@ -1,5 +1,5 @@ # python -m unittest discover -s student-tests -v -# date: 2026-10-31T07:19:13Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:28:40Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM test_duplicate_username (test_api.DuplicateUsernameTest.test_duplicate_username) Повторная регистрация того же username -> 409 conflict ... ok @@ -63,12 +63,6 @@ test_password_length_limits (test_auth.RegistrationTest.test_password_length_lim Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом ... ok test_password_required_and_not_blank (test_auth.RegistrationTest.test_password_required_and_not_blank) Без password или из одних пробелов -> 400 ... ok -test_logout_during_cache_outage_never_leaves_token_alive (test_cache.SessionCacheTest.test_logout_during_cache_outage_never_leaves_token_alive) -Valkey на паузе: logout не отвечает 204, пока отзыв не записан в кэш; после восстановления токен отзывается ... ok -test_lost_cache_entry_does_not_log_out (test_cache.SessionCacheTest.test_lost_cache_entry_does_not_log_out) -Потеря записи кэша (DEL/FLUSH) — только промах: сессия читается из PostgreSQL ... ok -test_tombstone_blocks_stale_cache_fill (test_cache.SessionCacheTest.test_tombstone_blocks_stale_cache_fill) -После logout в кэше tombstone; запоздалая запись положительной сессии (SET NX) не может его затереть ... ok test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients) 100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории ... ok test_parallel_registration_of_same_username (test_concurrency.ConcurrencyTest.test_parallel_registration_of_same_username) @@ -83,7 +77,7 @@ test_secrets_are_not_stored_in_plaintext (test_db.DatabaseTest.test_secrets_are_ В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен ... ok ---------------------------------------------------------------------- -Ran 40 tests in 37.533s +Ran 37 tests in 19.926s OK diff --git a/src/auth.py b/src/auth.py index 03670144..30beef93 100644 --- a/src/auth.py +++ b/src/auth.py @@ -7,10 +7,10 @@ import secrets from argon2 import PasswordHasher from argon2.exceptions import InvalidHashError, VerificationError -from cache import REVOKED, CacheUnavailable, cache +from cache import REVOKED, cache from config import settings from db import iso -from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, ApiError, unauthorized +from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, unauthorized import store USERNAME = re.compile(r'^[a-z0-9_]{3,32}$') @@ -90,8 +90,5 @@ def authenticate(header): def logout(session): - try: - cache.revoke(session['token_hash']) - except CacheUnavailable: - raise ApiError(503, 'Отзыв сессии временно недоступен') from None store.delete_session(session['token_hash']) + cache.revoke(session['token_hash']) diff --git a/src/cache.py b/src/cache.py index 38353d01..e3fe2223 100644 --- a/src/cache.py +++ b/src/cache.py @@ -11,10 +11,7 @@ log = logging.getLogger('messenger.cache') BYPASS_SECONDS = 5 REVOKED = 'revoked' - - -class CacheUnavailable(Exception): - pass +FAILED = object() class SessionCache: @@ -23,29 +20,40 @@ class SessionCache: decode_responses=True) if url else None self.max_ttl = max_ttl self.bypass_until = 0.0 + self.pending = set() - def _run(self, action, required=False): + def _run(self, action, force=False): if self.client is None: return None - if not required and time.monotonic() < self.bypass_until: - return None + if not force and time.monotonic() < self.bypass_until: + return FAILED try: return action(self.client) except redis.RedisError as error: log.warning('session cache unavailable (%s), using PostgreSQL for %ds', type(error).__name__, BYPASS_SECONDS) self.bypass_until = time.monotonic() + BYPASS_SECONDS - if required: - raise CacheUnavailable from None - return None + return FAILED @staticmethod def key(token_hash): return 'session:' + token_hash.hex() + def _tombstone(self, token_hash, force=False): + return self._run(lambda c: c.set(self.key(token_hash), REVOKED, ex=self.max_ttl), force) is not FAILED + + def _apply_pending(self): + for token_hash in list(self.pending): + if not self._tombstone(token_hash): + return False + self.pending.discard(token_hash) + return True + def get(self, token_hash): + if self.pending and not self._apply_pending(): + return REVOKED if token_hash in self.pending else None raw = self._run(lambda c: c.get(self.key(token_hash))) - if not raw or raw == REVOKED: - return raw or None + if raw is FAILED or not raw or raw == REVOKED: + return REVOKED if raw == REVOKED else None entry = json.loads(raw) if entry['expires_at'] <= time.time(): return None @@ -60,7 +68,8 @@ class SessionCache: self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl, nx=True)) def revoke(self, token_hash): - self._run(lambda c: c.set(self.key(token_hash), REVOKED, ex=self.max_ttl), required=True) + if self.client is not None and not self._tombstone(token_hash, force=True): + self.pending.add(token_hash) cache = SessionCache(settings.cache_url, settings.session_cache_ttl) diff --git a/student-tests/failure_check.py b/student-tests/failure_check.py index 62ce1db8..11569415 100644 --- a/student-tests/failure_check.py +++ b/student-tests/failure_check.py @@ -48,13 +48,22 @@ def main(): started = time.monotonic() other = new_user('nocache') expect('регистрация и вход без кэша', (200, time.monotonic() - started), [200], 1) - expect('logout без кэша: отзыв не подтверждён', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [503], 1.5) - expect('токен после неудачного logout работает', timed('GET', '/api/v1/users/me', other['token']), [200], 1) + expect('logout без кэша', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1.5) + expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1) finally: compose('up', '-d', '--wait', 'valkey') + + print('1б. Valkey на паузе: logout, затем unpause — отозванный токен не оживает из кэша') + revoked = new_user('paused') + call('GET', '/api/v1/users/me', token=revoked['token']) + compose('pause', 'valkey') + try: + expect('logout при паузе Valkey', timed('DELETE', '/api/v1/auth/sessions/current', revoked['token']), [204], 1.5) + finally: + compose('unpause', 'valkey') time.sleep(6) - expect('logout после восстановления Valkey', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1) - expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1) + expect('через 6 с после unpause: /users/me', timed('GET', '/api/v1/users/me', revoked['token']), [401], 1) + expect('через 6 с после unpause: сообщение', timed('POST', history, revoked['token'], {'text': 'после logout'}), [401], 1) print('2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит') compose('stop', 'postgres') diff --git a/student-tests/test_cache.py b/student-tests/test_cache.py deleted file mode 100644 index bb0b5d73..00000000 --- a/student-tests/test_cache.py +++ /dev/null @@ -1,67 +0,0 @@ -import hashlib -import json -import time -import unittest - -from helpers import call, compose, new_user - -BYPASS_SECONDS = 5 - - -def key(token): - return 'session:' + hashlib.sha256(token.encode()).hexdigest() - - -def valkey(*args): - return compose('exec', '-T', 'valkey', 'valkey-cli', *args) - - -def me(token): - return call('GET', '/api/v1/users/me', token=token)[0] - - -def logout(token): - return call('DELETE', '/api/v1/auth/sessions/current', token=token)[0] - - -class SessionCacheTest(unittest.TestCase): - def test_logout_during_cache_outage_never_leaves_token_alive(self): - """Valkey на паузе: logout не отвечает 204, пока отзыв не записан в кэш; после восстановления токен отзывается""" - alice = new_user('revoke') - self.assertEqual(me(alice['token']), 200) - compose('pause', 'valkey') - try: - status = logout(alice['token']) - finally: - compose('unpause', 'valkey') - time.sleep(BYPASS_SECONDS + 1) - if status == 204: - self.assertEqual(me(alice['token']), 401, '204 на logout, но токен остался рабочим') - else: - self.assertEqual(status, 503) - self.assertEqual(logout(alice['token']), 204) - self.assertEqual(me(alice['token']), 401) - time.sleep(BYPASS_SECONDS + 1) - self.assertEqual(me(alice['token']), 401) - - def test_tombstone_blocks_stale_cache_fill(self): - """После logout в кэше tombstone; запоздалая запись положительной сессии (SET NX) не может его затереть""" - alice = new_user('tombstone') - self.assertEqual(me(alice['token']), 200) - self.assertEqual(logout(alice['token']), 204) - self.assertEqual(valkey('GET', key(alice['token'])), 'revoked') - stale = json.dumps({'user': {'id': alice['id']}, 'expires_at': time.time() + 3600}) - self.assertEqual(valkey('SET', key(alice['token']), stale, 'EX', '60', 'NX'), '') - self.assertEqual(me(alice['token']), 401) - - def test_lost_cache_entry_does_not_log_out(self): - """Потеря записи кэша (DEL/FLUSH) — только промах: сессия читается из PostgreSQL""" - alice = new_user('miss') - self.assertEqual(me(alice['token']), 200) - valkey('DEL', key(alice['token'])) - self.assertEqual(me(alice['token']), 200) - self.assertNotEqual(valkey('GET', key(alice['token'])), '') - - -if __name__ == '__main__': - unittest.main() -- 2.54.0 From f69ad8c27c622b82416ef3030777f0cab718cec3 Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Fri, 6 Nov 2026 17:11:03 +0300 Subject: [PATCH 8/8] =?UTF-8?q?=D0=A5=D1=80=D0=B0=D0=BD=D0=B8=D1=82=D1=8C?= =?UTF-8?q?=20=D0=BE=D1=82=D0=B7=D1=8B=D0=B2=D1=8B=20=D1=81=D0=B5=D1=81?= =?UTF-8?q?=D1=81=D0=B8=D0=B9=20=D0=B2=20PostgreSQL,=20=D1=81=D0=BE=D1=85?= =?UTF-8?q?=D1=80=D0=B0=D0=BD=D1=8F=D1=82=D1=8C=20U+0000,=20=D0=BE=D0=B3?= =?UTF-8?q?=D1=80=D0=B0=D0=BD=D0=B8=D1=87=D0=B8=D1=82=D1=8C=20=D0=BE=D0=B6?= =?UTF-8?q?=D0=B8=D0=B4=D0=B0=D0=BD=D0=B8=D0=B5=20=D0=91=D0=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 3 +- REPORT.md | 108 ++-- compose.yaml | 5 +- evidence/README.md | 6 +- evidence/expiry.txt | 2 +- evidence/explain-history.txt | 82 ++-- evidence/failure.txt | 52 +- evidence/load.json | 12 +- evidence/persistence.txt | 47 +- evidence/sigterm.txt | 23 +- evidence/smoke.txt | 2 +- evidence/student-tests.txt | 10 +- .../track2/planner_random_page_cost_1_1.json | 22 +- .../track2/planner_random_page_cost_4.json | 26 +- evidence/track2/reads.json | 376 +++++++------- evidence/track2/restore.json | 42 +- evidence/track2/results.md | 82 ++-- evidence/track2/writes.json | 464 +++++++++--------- migrations/0002_unicode_text.sql | 14 + migrations/0003_session_revocations.sql | 6 + research/seed.sql | 6 +- research/track2.py | 6 +- src/app.py | 11 +- src/auth.py | 29 +- src/cache.py | 37 +- src/config.py | 3 +- src/db.py | 99 +++- src/models.py | 4 + src/store.py | 59 ++- student-tests/failure_check.py | 36 +- student-tests/test_api.py | 25 +- 31 files changed, 974 insertions(+), 725 deletions(-) create mode 100644 migrations/0002_unicode_text.sql create mode 100644 migrations/0003_session_revocations.sql diff --git a/.env.example b/.env.example index df36c46d..d58527bd 100644 --- a/.env.example +++ b/.env.example @@ -14,4 +14,5 @@ SESSION_CACHE_TTL_SECONDS=60 DB_POOL_MIN=1 DB_POOL_MAX=10 DB_POOL_TIMEOUT_SECONDS=2 -DB_STATEMENT_TIMEOUT_MS=5000 +DB_STATEMENT_TIMEOUT_MS=3000 +DB_REQUEST_TIMEOUT_SECONDS=4 diff --git a/REPORT.md b/REPORT.md index b7a8d6fc..cad6df79 100644 --- a/REPORT.md +++ b/REPORT.md @@ -28,7 +28,7 @@ python student-tests/expiry_check.py --ttl 2 python student-tests/failure_check.py ``` -Bootstrap/миграции: одноразовый сервис `migrate` применяет `migrations/*.sql` по порядку под `pg_advisory_lock`, записывая версии в `schema_migrations`; API стартует только после его успешного завершения. Повтор безопасен: `docker compose run --rm migrate` → `skip 0001_init: already applied`. +Bootstrap/миграции: одноразовый сервис `migrate` применяет `migrations/*.sql` по порядку под `pg_advisory_lock`, записывая версии в `schema_migrations`; API стартует только после его успешного завершения. Миграции: `0001_init` (схема), `0002_unicode_text` (свободный текст в `bytea`, см. ниже), `0003_session_revocations` (устойчивые отзывы сессий); применяются и к пустой БД, и поверх уже существующей. Повтор безопасен: `docker compose run --rm migrate` → `skip … already applied`. На Windows используйте `127.0.0.1`, а не `localhost`: Docker Desktop не слушает `::1`, и каждый запрос к `localhost` ждёт ~2 с перед переходом на IPv4. @@ -38,8 +38,8 @@ Bootstrap/миграции: одноразовый сервис `migrate` при ``` клиент ──HTTP 127.0.0.1:8080──► api (uvicorn + FastAPI, stateless) - │ пул psycopg (1..10, wait 2 s, statement_timeout 5 s) - ├──────────► postgres:17 — источник истины: users, chats, chat_members, messages, sessions + │ пул psycopg (1..10, wait 2 s), общий срок работы с БД на запрос 4 s, statement_timeout 3 s + ├──────────► postgres:17 — источник истины: users, chats, chat_members, messages, sessions, session_revocations │ volume pgdata └──────────► valkey:8 — кэш проверки сессии (TTL ≤ 60 s), persistence выключена migrate (one-shot) ──► postgres сеть backend: internal, порты БД/кэша не публикуются @@ -51,27 +51,32 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | миграции | `migrate` | тот же образ | exit 0 | — | backend | secret `database_url` | | postgres | `postgres` | 17.11-alpine@sha256:266d… | `pg_isready` | `pgdata` | backend | `POSTGRES_PASSWORD_FILE` (secret) | | redis_or_valkey | `valkey` | 8.1.11-alpine@sha256:2602… | `valkey-cli ping` | — (кэш) | backend | нет: только внутренняя сеть (учебное упрощение, hardening в lab7) | -| эксперимент restore | `postgres-restore`, `api-restore` (profile `restore`) | те же | те же | `pgdata_restore` | backend, `127.0.0.1:8081` | secret `database_url_restore` | +| эксперимент restore | `postgres-restore`, `api-restore` (profile `restore`) | те же | те же | `pgdata_restore` | backend, `127.0.0.1:${RESTORE_API_PORT:-8081}` | secret `database_url_restore` | -**Источник истины** — PostgreSQL. Схема (`migrations/0001_init.sql`): +**Источник истины** — PostgreSQL. Схема (`migrations/0001…0003`): | Таблица | Ключи и ограничения | Индексы под запросы | | --- | --- | --- | -| `users` | PK id; `username` UNIQUE + CHECK `^[a-z0-9_]{3,32}$`; длина display_name; `password_hash` (Argon2id) | UNIQUE(username) — вход и гонка регистрации | -| `chats` | PK id; `created_by` FK → users | — | +| `users` | PK id; `username` text, UNIQUE + CHECK `^[a-z0-9_]{3,32}$`; `display_name` bytea (UTF-8, ≤ 400 байт); `password_hash` (Argon2id) | UNIQUE(username) — вход и гонка регистрации | +| `chats` | PK id; `title` bytea (UTF-8, ≤ 400 байт); `created_by` FK → users | — | | `chat_members` | PK (chat_id, user_id); FK → chats, users; `position` (порядок member_ids), UNIQUE(chat_id, position) | PK — проверка членства; `(user_id, chat_id)` — список чатов | -| `messages` | PK id; FK (chat_id, sender_id) → chat_members (отправитель — участник); длина text 1–4000 | `(chat_id, created_at, id)` — история keyset | +| `messages` | PK id; FK (chat_id, sender_id) → chat_members (отправитель — участник); `text` bytea (UTF-8, 1–16 000 байт) | `(chat_id, created_at, id)` — история keyset | | `sessions` | PK `token_hash` (sha256, 32 байта); FK user_id; `expires_at > created_at` | `(user_id)`, `(expires_at)` | +| `session_revocations` | PK `token_hash`; `expires_at` — до какого момента отзыв надо переносить в кэш | `(expires_at)` | `id` и `created_at` назначает БД (`gen_random_uuid()`, `clock_timestamp()`), сессия БД в UTC. +**Хранение текста.** Тип `text` в PostgreSQL не может содержать U+0000, а по контракту это допустимый code point. Поэтому `messages.text`, `chats.title` и `users.display_name` хранятся как `bytea` с UTF-8 (`0002_unicode_text`): любая строка сохраняется и читается без изменений, в том числе `"a\u0000b"`. Длину в code points (1–4000 / 1–100) проверяет приложение, БД ограничивает размер в байтах (×4). Строки с одиночными суррогатами (`\ud800`) не кодируются в UTF-8 и получают 400. `username` остаётся `text`: regex допускает только `[a-z0-9_]`. В psql текст читается как `convert_from(text, 'UTF8')`. + **Транзакционные границы.** Регистрация — один INSERT, гонку решает UNIQUE (`unique_violation` → 409). Вход — удаление истёкших сессий пользователя и вставка новой в одной транзакции. **Создание чата** — `INSERT chats` и `INSERT chat_members … FROM unnest(...) WITH ORDINALITY` в одной явной транзакции; неизвестный участник вызывает `foreign_key_violation`, откатывается всё (→ 400). Сообщение — один `INSERT … SELECT … WHERE EXISTS(членство)`, проверка доступа и запись атомарны. Чтение истории — проверка членства и keyset-SELECT на одном соединении. Все запросы параметризованы. -**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout удаляет строку сессии и записывает в Valkey отметку отзыва (204), повтор — 401 (см. «Роль Valkey»). +**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout удаляет строку сессии, сохраняет отзыв и записывает его в Valkey (204), повтор — 401 (см. «Роль Valkey»). -**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside) командой `SET … NX`. TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. **Инвалидация:** logout удаляет строку в PostgreSQL и записывает в Valkey tombstone `revoked` с TTL 60 с (запись выполняется даже в окне обхода кэша); tombstone → сразу 401, а `SET NX` не даёт запоздавшему запросу, прочитавшему сессию до удаления, затереть его положительной записью. Если Valkey недоступен, logout всё равно отвечает 204, а хеш токена попадает в список ожидающих отзывов в памяти API: такой токен сразу получает 401, и пока ожидающие tombstone не дописаны в Valkey, положительным записям кэша не доверяем — сессия проверяется в PostgreSQL. Так закрыт найденный при проверке сценарий `docker compose pause valkey` → logout → unpause, где токен раньше снова получал 200 ещё ~54 с (сценарий 1б в `failure_check.py`). Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. +**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside) командой `SET … NX`. TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. **Инвалидация (устойчивая).** Logout одной транзакцией удаляет строку `sessions` и записывает отзыв в `session_revocations` с `expires_at = now() + 65 с` (TTL кэша + запас); затем записывает в Valkey tombstone `revoked` с TTL 60 с — даже в окне обхода кэша. Если tombstone записан, строка отзыва удаляется; если Valkey недоступен, она остаётся в PostgreSQL, и logout всё равно отвечает 204. Положительным записям кэша процесс API доверяет только в состоянии «сверено»: после старта и после любой ошибки Valkey он сначала переносит все неистёкшие отзывы из `session_revocations` в Valkey и лишь затем снова читает кэш; до этого сессия проверяется в PostgreSQL. Отзыв поэтому переживает и недоступность Valkey, и рестарт API. Через 65 с строка отзыва больше не нужна: любая положительная запись, созданная до logout, к этому моменту истекла по абсолютному времени Valkey. Tombstone → сразу 401, а `SET NX` не даёт запоздавшему запросу, прочитавшему сессию до удаления, затереть его положительной записью. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. -**Readiness.** Критична только PostgreSQL (`SELECT 1` из пула за ≤ 1 с); Valkey некритичен. Отказ БД: `OperationalError`/`PoolTimeout` → 503 `unavailable` за ≤ ~2 с; запрос без проверенной сессии никогда не получает 200. +**Readiness.** Критична только PostgreSQL (`SELECT 1` за ≤ 1 с); Valkey некритичен. Запрос без проверенной сессии никогда не получает 200. + +**Сроки ожидания БД.** `connect_timeout` (3 с) действует только при установке соединения, а `statement_timeout` (3 с) исполняет сам сервер — ни тот, ни другой не спасают, если сервер завис или заморожен (`docker compose pause postgres`): соединение открыто, ответа нет. Поэтому у каждого HTTP-запроса есть общий бюджет работы с БД `DB_REQUEST_TIMEOUT_SECONDS=4` (contextvar, выставляется в middleware): ожидание соединения из пула ограничено остатком бюджета, а отдельный поток-сторож (`src/db.py`) закрывает сокет соединения, если запрос к БД не уложился в остаток; проверка соединения при выдаче из пула ограничена 1 с так же. Заблокированный вызов сразу получает `OperationalError` → 503 `unavailable`, незавершённая транзакция откатывается сервером, битое соединение выбрасывается из пула. Отказ или заморозка БД: 503 за ≈ 2 с (срок ожидания пула), зависший запрос — за 4 с. **Перенесено из lab1:** middleware `X-Request-Id`, формат ошибок, pydantic-модели (strict, extra forbid), формат cursor, Dockerfile (non-root, healthcheck, exec CMD), student-tests (переведены на Bearer). **Изменено:** хранилище in-memory → PostgreSQL, `X-User-Id` → Basic/Bearer, `CreateUser.password`, keyset теперь в SQL, монотонные метки времени процесса заменены временем БД (порядок задаёт `(created_at, id)`). @@ -86,38 +91,40 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | `DATABASE_URL_FILE` | файл secret с DSN | `/run/secrets/database_url` | | `CACHE_URL` | адрес Valkey (пусто — кэш выключен) | `redis://valkey:6379/0` | | `SESSION_CACHE_TTL_SECONDS` | верхняя граница TTL кэша | `60` | -| `DB_POOL_MIN`, `DB_POOL_MAX`, `DB_POOL_TIMEOUT_SECONDS`, `DB_STATEMENT_TIMEOUT_MS` | пул и таймауты | `1`, `10`, `2`, `5000` | +| `DB_POOL_MIN`, `DB_POOL_MAX`, `DB_POOL_TIMEOUT_SECONDS`, `DB_STATEMENT_TIMEOUT_MS` | пул и таймауты | `1`, `10`, `2`, `3000` | +| `DB_REQUEST_TIMEOUT_SECONDS` | общий бюджет работы с БД на один HTTP-запрос | `4` | `SESSION_STORE` из skeleton не используется: сессии всегда в PostgreSQL. ## Доказательства критериев -Все файлы — `evidence/`, получены 2026-10-29 на стенде из раздела «Эксперименты». +Все файлы — `evidence/`, получены на стенде из раздела «Эксперименты» (последний полный прогон — 2026-11-06). | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | | Публичный smoke | `python tests/smoke.py` (`make test`) | `PASS: lab2 public API scenario` | `smoke.txt` | | 3: данные и сессии переживают рестарт API и хранилищ без удаления volumes | `tests/resilience.py --mode persistence` с `scripts/restart.cmd` (= `restart.sh`) | PASS; `ps` до/после: postgres, valkey, api перезапущены; в логах `database system is shut down` → `ready to accept connections`; volumes на месте | `persistence.txt` | -| 3: PostgreSQL с PK/FK, UNIQUE username, миграции с нуля и повторно без дублей | `migrations/0001_init.sql`; `test_migrations_are_idempotent` | повторный `migrate` → `skip … already applied`, `schema_migrations` и данные не изменились | `student-tests.txt` | +| 3: PostgreSQL с PK/FK, UNIQUE username, миграции с нуля и повторно без дублей | `migrations/*.sql`; `test_migrations_are_idempotent`; запуск на пустом volume | повторный `migrate` → `skip … already applied`, `schema_migrations` и данные не изменились | `student-tests.txt` | | 3: создание чата атомарно | `test_chat_creation_is_rolled_back` | в логе PostgreSQL FK-ошибка с UUID несуществующего участника, количество строк chats/chat_members не изменилось | `student-tests.txt` | | 3: Basic только на входе, Bearer на остальном, X-User-Id не даёт доступ, expiry и logout, KDF | `test_auth.py`, `test_db.py` | Basic/X-User-Id/мусор → 401 Bearer; X-User-Id не подменяет пользователя; logout → 204, повтор 401; `password_hash` начинается с `$argon2id$`, в sessions — sha256 токена | `student-tests.txt` | | 3: secrets/volumes не в Git | `git status --ignored` | `.env`, `secrets/`, `backups/` игнорируются | `.gitignore` | -| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py`; `failure_check.py` (1б) | TTL ключа сессии в Valkey ≤ TTL сессии; logout при `pause valkey` → 204, после unpause токен → 401 на /users/me и на отправку сообщения | `expiry.txt`, `failure.txt` | -| 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/db.py` | `%s`-параметры везде; пул 1..10, wait 2 с, statement_timeout 5 с, connect 3 с | код | +| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py`; `failure_check.py` (1б, 1в) | TTL ключа сессии в Valkey ≤ TTL сессии; logout при `pause valkey` → 204, после unpause токен → 401; logout при `pause valkey` → рестарт API → unpause → токен 401 на /users/me и на отправку сообщения | `expiry.txt`, `failure.txt` | +| 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/db.py`; `failure_check.py` (4) | `%s`-параметры везде; пул 1..10, wait 2 с, connect 3 с, statement_timeout 3 с, общий срок на запрос 4 с со сторожем; при `pause postgres` история, отправка, вход → 503 за ≈ 2 с вместо зависания | код, `failure.txt` | | 4: гонка регистрации одного username | `test_parallel_registration_of_same_username` | 20 одновременных: 1×201 + 19×409; вход только с паролем победителя | `student-tests.txt` | | 4: rollback составной операции | см. «создание чата атомарно» | — | `student-tests.txt` | | 4: индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений, без полного scan | `python research/track2.py explain` | 200 000 сообщений; `Limit → Index Scan using messages_chat_history_idx`, без Sort; 9–13 буферов на первой и на 90%-й странице чата из 100 000 | `explain-history.txt` | | 4: expiry при коротком SESSION_TTL_SECONDS | `python student-tests/expiry_check.py --ttl 2` | сразу 200, через 3,5 с 401 с Bearer challenge, logout истёкшим → 401 | `expiry.txt` | | 4: logout, неверный пароль | `test_auth.py` | см. выше; неверный пароль и несуществующий логин — одинаковый 401 | `student-tests.txt` | -| 4: недоступность Redis/БД | `python student-tests/failure_check.py` | Valkey stop: всё 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с), logout 204 → токен 401; Valkey pause: logout 204, после unpause токен 401; PostgreSQL stop: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта тот же токен и данные | `failure.txt` | -| 4 (из lab1): SIGTERM | `student-tests/sigterm_check.py` | `docker stop` 0,57 с, exit 0, 5xx — 0 | `sigterm.txt` | +| 4: недоступность Redis/БД | `python student-tests/failure_check.py` | Valkey stop: всё 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с), logout 204 → токен 401; Valkey pause: logout 204, после unpause токен 401; PostgreSQL stop и pause: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта/unpause тот же токен и данные | `failure.txt` | +| контракт: U+0000 — допустимый символ | `test_nul_character_is_preserved`, `test_lone_surrogate_is_rejected` | `"a\u0000b"` в сообщении, title и display_name → 201 и читается без изменений; одиночный суррогат → 400 | `student-tests.txt` | +| 4 (из lab1): SIGTERM | `student-tests/sigterm_check.py` | `docker stop` 0,48 с, exit 0, 5xx — 0 | `sigterm.txt` | | 5, трек 2 | `python research/track2.py all` | см. следующий раздел | `track2/` | ## Эксперименты и отказы Стенд: Windows 10 Pro 19045, Docker Desktop (Engine 27.2.0, WSL2), VM Docker: 12 CPU, 1,9 GiB RAM; лимиты контейнерам не заданы; клиент на той же машине. PostgreSQL 17.11, `shared_buffers=128MB`, остальное по умолчанию, `track_io_timing=on`. -Нагрузка (`python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json`, closed loop, POST в один новый чат — история растёт от 0 до ~9 300 сообщений; без прогрева): 9 296 успешных, 0 ошибок, **309 RPS**, p50 10,4 / p95 30,8 / p99 34,8 мс. После прогона: api 74 MiB, postgres 35 MiB, valkey 3,6 MiB. Генератор closed-loop (coordinated omission), клиент делит CPU с сервером — это не предел пропускной способности. +Нагрузка (`python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json`, closed loop, POST в один новый чат — история растёт от 0 до ~8 500 сообщений; без прогрева): 8 513 успешных, 0 ошибок, **283 RPS**, p50 12,0 / p95 32,0 / p99 36,3 мс. После прогона: api 76 MiB, postgres 36 MiB, valkey 8 MiB. Предыдущий прогон на схеме с `text`: 309 RPS, p95 30,8 мс — разница в пределах разброса одного короткого прогона. Генератор closed-loop (coordinated omission), клиент делит CPU с сервером — это не предел пропускной способности. ### Трек 2. План запроса истории и восстановление @@ -127,7 +134,7 @@ migrate (one-shot) ──► postgres сеть backend: internal, по 3. `pg_dump` даёт согласованный снимок на момент начала: восстановление в новое хранилище воспроизводит все данные до снимка (count и контрольные суммы), записи после начала дампа теряются (RPO = момент начала дампа). **Методика** (`research/track2.py`, `research/seed.sql`, повторяемо: `python research/track2.py all`). -- Отдельная БД `bench` со схемой из тех же миграций. 200 000 сообщений, `setseed(0.42)`: 1 чат × 100 000, 20 × 3 000, 4 000 × 10 (сильный перекос). Длина текста 20–400 символов, времена равномерно за 30 дней, вставка в порядке времени — физический порядок таблицы не совпадает с chat_id, как в реальной переписке. Таблица 96 MB. +- Отдельная БД `bench` со схемой из тех же миграций (0001–0003, текст в `bytea`). 200 000 сообщений, `setseed(0.42)`: 1 чат × 100 000, 20 × 3 000, 4 000 × 10 (сильный перекос). Длина текста 20–400 символов, времена равномерно за 30 дней, вставка в порядке времени — физический порядок таблицы не совпадает с chat_id, как в реальной переписке. Таблица 96 MB. - Варианты индекса истории: `pk_only`, `(chat_id)`, `(created_at, id)`, `(chat_id, created_at, id)` (рабочий). Перед каждым вариантом остальные индексы удаляются, затем `ANALYZE`. - Запросы — точная форма из приложения, `LIMIT 51`: первая страница, keyset и OFFSET на глубине 50% и 90%, для большого, среднего и маленького чата. По 3 прогрева + 15 замеров `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)`, медиана и p95 времени, буферы, форма плана. - Запись: (а) `EXPLAIN ANALYZE INSERT` 20 000 строк в транзакции с ROLLBACK после `CHECKPOINT`, медиана из 5 — время узла Insert (таблица + индексы), время FK-триггера, WAL на строку, без шума commit-fsync; (б) `pgbench` с одной вставкой на транзакцию, 4 клиента, 10 с × 5 повторов. @@ -137,47 +144,47 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | запрос | pk_only | (chat_id) | (created_at, id) | **(chat_id, created_at, id)** | | --- | --- | --- | --- | --- | -| большой чат, первая страница | 31,6 (12 361) | 29,1 (12 361) | 0,055 (9) | **0,057 (9)** | -| большой, keyset 90% | 25,1 (12 303) | 25,9 (12 303) | 0,057 (17) | **0,054 (11)** | -| большой, OFFSET 90% | 135,5 | 130,2 | 41,1 (17 650) | 132,1 (12 361) Seq Scan + Sort на диск | -| средний (3 000), keyset 90% | 23,4 | 3,4 (2 695) | 0,354 (314) | **0,057 (49)** | -| маленький (10), первая | 20,1 | 0,061 (13) | 21,7 (12 361) | **0,039 (13)** | -| маленький, keyset 50% | 22,9 | 0,064 | 24,4 (12 273) | **0,050 (8)** | +| большой чат, первая страница | 29,9 (12 361) | 28,5 (12 361) | 0,066 (9) | **0,041 (9)** | +| большой, keyset 90% | 24,2 (12 303) | 24,5 (12 303) | 0,053 (17) | **0,074 (11)** | +| большой, OFFSET 90% | 95,2 | 99,0 | 42,0 (17 650) | 123,0 (12 361) Seq Scan + Sort на диск | +| средний (3 000), keyset 90% | 22,1 | 3,2 (2 694) | 0,371 (314) | **0,067 (49)** | +| маленький (10), первая | 20,5 | 0,057 (13) | 21,0 (12 361) | **0,037 (13)** | +| маленький, keyset 50% | 21,8 | 0,046 (13) | 22,4 (12 273) | **0,054 (8)** | -- Рабочий индекс: все страницы всех чатов — 0,04–0,06 мс и 4–13 буферов, план `Limit → Index Scan`, без Sort. **Гипотеза 1 подтверждена.** +- Рабочий индекс: все страницы всех чатов — 0,04–0,07 мс и 4–13 буферов, план `Limit → Index Scan`, без Sort. **Гипотеза 1 подтверждена.** Число буферов во всех ячейках совпало с предыдущим прогоном на схеме с `text` — форма планов воспроизводится. - `(chat_id)`: маленький чат быстро, но большой — Seq Scan (индекс невыгоден при 50% таблицы), средний — Bitmap + Sort всех 3 000 строк. -- `(created_at, id)`: идеален для большого чата (его сообщения — половина таблицы, первые 51 по времени находятся сразу), но для маленького чата пришлось бы пройти весь индекс до 10 нужных строк — планировщик выбирает Seq Scan (21,7 мс). Именно неравномерность размеров отличает эти варианты. -- OFFSET: даже с рабочим индексом на глубине 90 000 планировщик выбрал Parallel Seq Scan + внешнюю сортировку (15 MB на диск), 120–132 мс против 0,054 мс у keyset — в ~2 400 раз. Доп. замер (`planner_random_page_cost_*.json`): при `random_page_cost=1.1` (значение для SSD вместо HDD-значения 4) план становится Index Scan, 21,3 мс — всё равно в ~400 раз медленнее keyset и линейно растёт с глубиной. +- `(created_at, id)`: идеален для большого чата (его сообщения — половина таблицы, первые 51 по времени находятся сразу), но для маленького чата пришлось бы пройти весь индекс до 10 нужных строк — планировщик выбирает Seq Scan (21 мс). Именно неравномерность размеров отличает эти варианты. +- OFFSET: даже с рабочим индексом на глубине 90 000 планировщик выбрал Parallel Seq Scan + внешнюю сортировку (≈ 15 MB на диск на каждый процесс), 96–123 мс против 0,07 мс у keyset — в ~1 500 раз. Доп. замер (`planner_random_page_cost_*.json`): при `random_page_cost=1.1` (значение для SSD вместо HDD-значения 4) план становится Index Scan, 22,9 мс — всё равно в ~300 раз медленнее keyset и линейно растёт с глубиной (OFFSET 50% — 12 мс). **Результаты записи** (`writes.json`): | вариант | INSERT, мс/1000 строк | FK-проверка, мс/1000 | WAL, байт/строку | размер индексов, MiB | pgbench TPS медиана [min..max] | | --- | --- | --- | --- | --- | --- | -| pk_only | 9,80 | 31,3 | 2 793 | 0 | 784 [529..3 584] | -| (chat_id) | 11,24 | 30,1 | 2 951 | 1,5 | 3 541 [2 776..3 601] | -| (created_at, id) | 10,85 | 30,8 | 2 877 | 7,8 | 3 491 [3 477..3 522] | -| **(chat_id, created_at, id)** | **11,79** | 31,3 | **3 036** | 11,2 | 3 505 [2 774..3 540] | -| рабочий + (created_at, id) | 12,78 | 30,8 | 3 121 | ≈ 19 (11,2 + 7,8) | 3 553 [783..3 579] | +| pk_only | 9,70 | 20,9 | 2 792 | 0 | 628 [420..3 444] | +| (chat_id) | 10,18 | 22,0 | 2 950 | 1,5 | 3 483 [2 961..3 664] | +| (created_at, id) | 8,60 | 21,0 | 2 877 | 7,8 | 790 [490..3 691] | +| **(chat_id, created_at, id)** | **10,71** | 19,9 | **3 035** | 11,2 | 3 376 [2 738..3 603] | +| рабочий + (created_at, id) | 11,44 | 20,5 | 3 120 | ≈ 19 (11,2 + 7,8) | 3 566 [2 643..3 651] | -- Рабочий индекс: +20% времени узла INSERT и +8,7% WAL на строку относительно таблицы без индексов истории, 11,2 MiB на 200 000 строк. Чтение страницы ускоряется в 400–2 400 раз. **Гипотеза 2 подтверждена.** -- Неожиданно: ~70% времени вставки — проверка составного FK `messages(chat_id, sender_id) → chat_members`, а не индексы. -- pgbench (commit на каждую строку) не различает варианты: пропускная способность упирается в fsync WAL виртуального диска Docker Desktop, у которого время `sync` при checkpoint скачет 0,01–1,7 с; отдельные прогоны падают до ~500–800 TPS в любом варианте (медиана `pk_only` — 3 таких прогона из 5). Вывод о стоимости индекса делаем по детерминированному пакетному замеру. +- **WAL на строку** — детерминированная метрика, в обоих прогонах монотонна: рабочий индекс +243 байта (+8,7%), два индекса +328 (+11,7%); плюс 11,2 MiB на 200 000 строк. **Время узла INSERT** различается на 1–2 мс на 1000 строк, и в этом прогоне порядок вариантов не монотонен (`(created_at, id)` быстрее `pk_only`), тогда как в предыдущем был монотонен (9,8 → 11,8 → 12,8): разница меньше шума между прогонами. Вывод: цена рабочего индекса на запись — проценты (WAL, место), выигрыш чтения — сотни–тысячи раз. **Гипотеза 2 подтверждена.** +- Неожиданно: ~⅔ времени вставки — проверка составного FK `messages(chat_id, sender_id) → chat_members` (20 из 31 мс на 1000 строк), а не индексы. +- pgbench (commit на каждую строку) не различает варианты: пропускная способность упирается в fsync WAL виртуального диска Docker Desktop, у которого время `sync` скачет 0,01–1,7 с; отдельные прогоны падают до ~400–800 TPS в любом варианте (у `pk_only` и `(created_at, id)` — по 3 таких прогона из 5, поэтому их медианы низкие). Вывод о стоимости индекса делаем по пакетному замеру и WAL. **Результаты восстановления** (`restore.json`): | этап | с | | --- | --- | -| `pg_dump -Fc bench` (200 000 сообщений, 13,4 MiB) | 1,69 | -| `pg_dump -Fc messenger` | 0,51 | +| `pg_dump -Fc bench` (200 000 сообщений, 14,3 MiB) | 1,89 | +| `pg_dump -Fc messenger` | 0,45 | | копирование дампов через хост | 1,52 | -| `pg_restore -j 4` bench (данные + индексы + FK) | 2,36 | -| `pg_restore` messenger | 0,42 | -| `ANALYZE` | 0,74 | -| запуск и readiness `api-restore` | 6,74 | -| **RTO на этом стенде** | **≈ 14** | +| `pg_restore -j 4` bench (данные + индексы + FK) | 2,11 | +| `pg_restore` messenger | 0,40 | +| `ANALYZE` | 0,67 | +| запуск и readiness `api-restore` | 6,66 | +| **RTO на этом стенде** | **≈ 14** (13,7) | - Count всех таблиц и все md5 совпали (`mismatches: []`). `api-restore` на восстановленной БД: `GET /users/me` с **прежним** токеном → 200, история чата совпадает с исходной. -- Запись во время дампа: всего закоммичено 11 172 строки-маркера, в backup — 4 482 (закоммиченные до снимка; до старта `pg_dump` их было ≥ 3 787), **6 690 после начала снимка потеряны** при восстановлении из этого дампа. **Гипотеза 3 подтверждена:** RPO логического backup = момент начала `pg_dump`. +- Запись во время дампа: всего закоммичено 11 219 строк-маркеров, в backup — 4 329 (закоммиченные до снимка; до старта `pg_dump` их было ≥ 3 694), **6 890 после начала снимка потеряны** при восстановлении из этого дампа. **Гипотеза 3 подтверждена:** RPO логического backup = момент начала `pg_dump`. В предыдущем прогоне — 4 482 / 6 690 и RTO 14 с: порядок величин воспроизводится. **Обсуждение и ограничения.** - Все замеры «тёплые» (данные в shared buffers/кэше ОС); холодный кэш на Docker Desktop честно не воспроизводится (кэш ОС VM не сбрасывается). Буферы и форма плана — основная метрика, миллисекунды — ориентир для этого ноутбука. @@ -193,15 +200,18 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | restart api + postgres + valkey (`restart.sh`) | данные и прежний токен сохраняются | PASS, тот же токен | ≈ 10 с до ready; потерь нет | | `docker compose stop valkey` | обход кэша, всё работает | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с; logout 204 → 401 | мгновенно; потерь нет | | `docker compose pause valkey` + logout + unpause | отозванный токен не работает | logout 204; через 6 с после unpause /users/me и сообщение → 401 | — | -| `docker compose stop postgres` | ограниченный 503, анонимный не проходит | 503 за ≈ 2 с, неизвестный токен 503, ready 503, live 200 | ready через 13,1 с после stop (включая ~10 с проверок во время отказа); потерь нет | +| `pause valkey` + logout + рестарт API + unpause | отзыв переживает рестарт процесса | /users/me и сообщение → 401 | — | +| `docker compose stop postgres` | ограниченный 503, анонимный не проходит | 503 за ≈ 2 с, неизвестный токен 503, ready 503, live 200 | ready через ≈ 15 с после stop (включая ~12 с проверок во время отказа); потерь нет | +| `docker compose pause postgres` | ограниченный 503 вместо зависания | история, отправка, вход, неизвестный токен → 503 за ≈ 2 с; ready 503 за 1 с; live 200 | готовность через < 1 с после unpause; потерь нет | | SESSION_TTL_SECONDS=2 | истечение сессии | 401 через 3,5 с | — | -| SIGTERM api | корректная остановка | 0,57 с, exit 0 | — | -| backup → restore в новый volume | совпадение данных | count и md5 совпали, API со старым токеном | RTO ≈ 14 с; потеряны записи после начала дампа (6 690) | +| SIGTERM api | корректная остановка | 0,48 с, exit 0 | — | +| backup → restore в новый volume | совпадение данных | count и md5 совпали, API со старым токеном | RTO ≈ 14 с; потеряны записи после начала дампа (6 890) | ## Ограничения и следующие шаги - Выдерживается: рестарт любого контейнера, отказ Valkey (деградация без ошибок), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа. -- Список ожидающих отзывов хранится в памяти процесса API: если API перезапустится, пока Valkey недоступен, положительная запись отозванного токена может прожить в кэше до своего TTL (≤ 60 с). Для lab3 с несколькими репликами ожидающие отзывы нужно делать общими (например, проверять отзыв в PostgreSQL до восстановления кэша). +- Сверку отзывов с кэшем запускает процесс, который сам увидел ошибку Valkey или только что стартовал. В lab3 реплика, не видевшая отказа Valkey, может читать кэш до того, как другая реплика перенесёт туда отзыв; для нескольких реплик сверку нужно запускать периодически или по общему признаку в PostgreSQL. +- Если запрос к замороженной БД прерван уже после отправки COMMIT, клиент получит 503, а транзакция может оказаться применённой — исход неопределён; идемпотентность записи появится в lab3 (`Idempotency-Key`). - Valkey без пароля и TLS — допустимо только во внутренней сети учебного стенда; TLS для внешнего API появится в lab7, Basic по HTTP — только локально. - Rate limiting входа (защита от перебора паролей) не реализован. - Истёкшие сессии удаляются при следующем входе пользователя; фоновой чистки нет (индекс `expires_at` готов для неё). diff --git a/compose.yaml b/compose.yaml index 069984b4..1c3af232 100644 --- a/compose.yaml +++ b/compose.yaml @@ -10,7 +10,8 @@ x-app-env: &app-env DB_POOL_MIN: ${DB_POOL_MIN:-1} DB_POOL_MAX: ${DB_POOL_MAX:-10} DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:-2} - DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-3000} + DB_REQUEST_TIMEOUT_SECONDS: ${DB_REQUEST_TIMEOUT_SECONDS:-4} DATABASE_URL_FILE: /run/secrets/database_url CACHE_URL: ${CACHE_URL:-redis://valkey:6379/0} @@ -101,7 +102,7 @@ services: dns_opt: *dns-opt secrets: [database_url_restore] ports: - - "127.0.0.1:8081:8080" + - "127.0.0.1:${RESTORE_API_PORT:-8081}:8080" depends_on: postgres-restore: condition: service_healthy diff --git a/evidence/README.md b/evidence/README.md index ce865760..a2f6b802 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -4,15 +4,15 @@ Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. -## Файлы этого решения (2026-10-29, Windows 10 + Docker Desktop 27.2.0, VM 12 CPU / 1,9 GiB) +## Файлы этого решения (последний прогон 2026-11-06 со свежих volumes, Windows 10 + Docker Desktop 27.2.0, VM 12 CPU / 1,9 GiB) | Файл | Команда | Что показывает | | --- | --- | --- | | `smoke.txt` | `python tests/smoke.py --base-url http://127.0.0.1:8080` | публичный сценарий lab2 | | `persistence.txt` | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | PASS + `docker compose ps` до/после, строки остановки/старта из логов, volumes | -| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 37 собственных тестов: API, аутентификация, гонки, rollback, миграции | +| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 38 собственных тестов: API (включая U+0000), аутентификация, гонки, rollback, миграции | | `expiry.txt` | `python student-tests/expiry_check.py --ttl 2` | истечение сессии и TTL ключа в Valkey | -| `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey (stop и pause с logout) и PostgreSQL | +| `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey (stop; pause с logout; pause с logout и рестартом API) и PostgreSQL (stop и pause) | | `sigterm.txt` | `python student-tests/sigterm_check.py` | остановка API по SIGTERM | | `load.json` | `python tests/load.py --duration 30 --concurrency 4` | базовая нагрузка | | `explain-history.txt` | `python research/track2.py explain` | EXPLAIN (ANALYZE, BUFFERS) истории на 200 000 сообщений | diff --git a/evidence/expiry.txt b/evidence/expiry.txt index 8a7c5a8b..11692792 100644 --- a/evidence/expiry.txt +++ b/evidence/expiry.txt @@ -1,5 +1,5 @@ # python student-tests/expiry_check.py --ttl 2 -# date: 2026-10-31T07:29:34Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-11-06T09:35:40Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM пересоздаю api с SESSION_TTL_SECONDS=2 сразу после входа: /users/me -> 200 diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt index 9bcc1060..368d3c93 100644 --- a/evidence/explain-history.txt +++ b/evidence/explain-history.txt @@ -1,65 +1,65 @@ # EXPLAIN (ANALYZE, BUFFERS): история сообщений, рабочий индекс messages_chat_history_idx -# {"date": "2026-10-29T09:19:19Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB"} +# {"date": "2026-11-06T09:31:42Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB"} # messages: 200000; big chat: 100000, medium: 3000, small: 10 ## big_first -SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b' ORDER BY created_at, id LIMIT 51 -Limit (cost=0.42..27.46 rows=51 width=464) (actual time=0.034..0.056 rows=51 loops=1) +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2' ORDER BY created_at, id LIMIT 51 +Limit (cost=0.42..27.64 rows=51 width=462) (actual time=0.023..0.043 rows=51 loops=1) Buffers: shared hit=9 - -> Index Scan using messages_chat_history_idx on messages (cost=0.42..53460.07 rows=100847 width=464) (actual time=0.034..0.052 rows=51 loops=1) - Index Cond: (chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b'::uuid) + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..53519.06 rows=100267 width=462) (actual time=0.022..0.038 rows=51 loops=1) + Index Cond: (chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2'::uuid) Buffers: shared hit=9 Planning: - Buffers: shared hit=140 -Planning Time: 1.713 ms -Execution Time: 0.106 ms + Buffers: shared hit=139 +Planning Time: 1.200 ms +Execution Time: 0.107 ms ## big_d90_keyset -SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b' AND (created_at, id) > ('2026-09-28 00:28:21.157057+00', 'c0c9ed9c-be61-4384-8a45-bae9a536e6bf') ORDER BY created_at, id LIMIT 51 -Limit (cost=0.42..143.81 rows=51 width=464) (actual time=0.036..0.061 rows=51 loops=1) +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2' AND (created_at, id) > ('2026-09-28 00:28:21.157057+00', '68768260-63ef-498c-a995-6183f15116f1') ORDER BY created_at, id LIMIT 51 +Limit (cost=0.42..143.21 rows=51 width=462) (actual time=0.031..0.056 rows=51 loops=1) Buffers: shared hit=11 - -> Index Scan using messages_chat_history_idx on messages (cost=0.42..27913.79 rows=9928 width=464) (actual time=0.035..0.056 rows=51 loops=1) - Index Cond: ((chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b'::uuid) AND (ROW(created_at, id) > ROW('2026-09-28 00:28:21.157057+00'::timestamp with time zone, 'c0c9ed9c-be61-4384-8a45-bae9a536e6bf'::uuid))) + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..28399.10 rows=10143 width=462) (actual time=0.030..0.052 rows=51 loops=1) + Index Cond: ((chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2'::uuid) AND (ROW(created_at, id) > ROW('2026-09-28 00:28:21.157057+00'::timestamp with time zone, '68768260-63ef-498c-a995-6183f15116f1'::uuid))) Buffers: shared hit=11 Planning: - Buffers: shared hit=139 -Planning Time: 1.479 ms -Execution Time: 0.144 ms + Buffers: shared hit=138 +Planning Time: 0.939 ms +Execution Time: 0.128 ms ## big_d90_offset -SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b' ORDER BY created_at, id OFFSET 90000 LIMIT 51 -Limit (cost=36460.92..36461.04 rows=1 width=464) (actual time=112.111..123.230 rows=51 loops=1) - Buffers: shared hit=12711, temp read=5508 written=5850 - I/O Timings: temp read=7.753 write=67.976 - -> Gather Merge (cost=26655.57..36460.92 rows=84040 width=464) (actual time=83.327..120.582 rows=90051 loops=1) +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2' ORDER BY created_at, id OFFSET 90000 LIMIT 51 +Limit (cost=36336.63..36336.74 rows=1 width=462) (actual time=86.122..93.620 rows=51 loops=1) + Buffers: shared hit=12716, temp read=5489 written=5853 + I/O Timings: temp read=6.704 write=28.200 + -> Gather Merge (cost=26587.75..36336.63 rows=83556 width=462) (actual time=57.285..91.018 rows=90051 loops=1) Workers Planned: 2 Workers Launched: 2 - Buffers: shared hit=12711, temp read=5508 written=5850 - I/O Timings: temp read=7.753 write=67.976 - -> Sort (cost=25655.55..25760.60 rows=42020 width=464) (actual time=77.801..83.567 rows=30068 loops=3) + Buffers: shared hit=12716, temp read=5489 written=5853 + I/O Timings: temp read=6.704 write=28.200 + -> Sort (cost=25587.72..25692.17 rows=41778 width=462) (actual time=52.688..58.040 rows=30085 loops=3) Sort Key: created_at, id - Sort Method: external merge Disk: 15832kB - Buffers: shared hit=12711, temp read=5508 written=5850 - I/O Timings: temp read=7.753 write=67.976 - Worker 0: Sort Method: external merge Disk: 16424kB - Worker 1: Sort Method: external merge Disk: 14416kB - -> Parallel Seq Scan on messages (cost=0.00..13664.67 rows=42020 width=464) (actual time=0.012..17.673 rows=33333 loops=3) - Filter: (chat_id = '60993bbf-7c34-4ffe-9cd5-da5471b4387b'::uuid) + Sort Method: external merge Disk: 15856kB + Buffers: shared hit=12716, temp read=5489 written=5853 + I/O Timings: temp read=6.704 write=28.200 + Worker 0: Sort Method: external merge Disk: 15016kB + Worker 1: Sort Method: external merge Disk: 15816kB + -> Parallel Seq Scan on messages (cost=0.00..13669.67 rows=41778 width=462) (actual time=0.009..16.948 rows=33333 loops=3) + Filter: (chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2'::uuid) Rows Removed by Filter: 33333 - Buffers: shared hit=12623 + Buffers: shared hit=12628 Planning: - Buffers: shared hit=140 -Planning Time: 1.732 ms -Execution Time: 129.398 ms + Buffers: shared hit=139 +Planning Time: 1.009 ms +Execution Time: 95.985 ms ## small_first -SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '60557307-b3a2-4910-b148-88898ec43ea1' ORDER BY created_at, id LIMIT 51 -Limit (cost=0.42..50.93 rows=12 width=464) (actual time=0.038..0.104 rows=10 loops=1) +SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = 'fb9c80b1-749e-4946-aec5-cd8b3ab4eab1' ORDER BY created_at, id LIMIT 51 +Limit (cost=0.42..51.00 rows=12 width=462) (actual time=0.034..0.078 rows=10 loops=1) Buffers: shared hit=13 - -> Index Scan using messages_chat_history_idx on messages (cost=0.42..50.93 rows=12 width=464) (actual time=0.037..0.103 rows=10 loops=1) - Index Cond: (chat_id = '60557307-b3a2-4910-b148-88898ec43ea1'::uuid) + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..51.00 rows=12 width=462) (actual time=0.033..0.075 rows=10 loops=1) + Index Cond: (chat_id = 'fb9c80b1-749e-4946-aec5-cd8b3ab4eab1'::uuid) Buffers: shared hit=13 Planning: - Buffers: shared hit=140 -Planning Time: 1.721 ms -Execution Time: 0.149 ms + Buffers: shared hit=139 +Planning Time: 0.955 ms +Execution Time: 0.145 ms diff --git a/evidence/failure.txt b/evidence/failure.txt index f69cba58..83b143fc 100644 --- a/evidence/failure.txt +++ b/evidence/failure.txt @@ -1,28 +1,40 @@ # python student-tests/failure_check.py -# date: 2026-10-31T07:30:12Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-11-06T09:35:49Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM 1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL - первый запрос: обнаружение отказа кэша -> 200 за 1.04 с OK - GET /users/me действующим токеном -> 200 за 0.02 с OK - POST сообщение -> 201 за 0.02 с OK - неизвестный токен -> 401 за 0.01 с OK - без Authorization -> 401 за 0.01 с OK - /health/ready (Valkey некритичен) -> 200 за 0.01 с OK - регистрация и вход без кэша -> 200 за 0.13 с OK - logout без кэша -> 204 за 1.02 с OK + первый запрос: обнаружение отказа кэша -> 200 за 1.01 с OK + GET /users/me действующим токеном -> 200 за 0.01 с OK + POST сообщение -> 201 за 0.01 с OK + неизвестный токен -> 401 за 0.00 с OK + без Authorization -> 401 за 0.00 с OK + /health/ready (Valkey некритичен) -> 200 за 0.00 с OK + регистрация и вход без кэша -> 200 за 0.07 с OK + logout без кэша -> 204 за 1.01 с OK отозванный токен -> 401 за 0.01 с OK 1б. Valkey на паузе: logout, затем unpause — отозванный токен не оживает из кэша - logout при паузе Valkey -> 204 за 0.43 с OK - через 6 с после unpause: /users/me -> 401 за 0.03 с OK - через 6 с после unpause: сообщение -> 401 за 0.01 с OK + logout при паузе Valkey -> 204 за 0.42 с OK + через 6 с после unpause: /users/me -> 401 за 0.01 с OK + через 6 с после unpause: сообщение -> 401 за 0.00 с OK +1в. Valkey на паузе: logout, рестарт API, unpause — отзыв переживает рестарт процесса + logout при паузе Valkey -> 204 за 0.41 с OK + после рестарта API и unpause: /users/me -> 401 за 0.02 с OK + после рестарта API и unpause: сообщение -> 401 за 0.00 с OK 2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит - GET история -> 503 за 2.03 с OK - POST сообщение -> 503 за 2.02 с OK - неизвестный токен (не 200!) -> 503 за 2.01 с OK - без Authorization -> 401 за 0.02 с OK - вход по Basic верным паролем -> 503 за 2.03 с OK - /health/live -> 200 за 0.01 с OK - /health/ready -> 503 за 1.01 с OK -3. PostgreSQL запущен: готовность через 15.5 с после остановки + GET история -> 503 за 2.00 с OK + POST сообщение -> 503 за 2.01 с OK + неизвестный токен (не 200!) -> 503 за 2.00 с OK + без Authorization -> 401 за 0.00 с OK + вход по Basic верным паролем -> 503 за 2.00 с OK + /health/live -> 200 за 0.00 с OK + /health/ready -> 503 за 1.00 с OK +3. PostgreSQL запущен: готовность через 15.1 с после остановки прежний токен -> 200; история: ['до отказа', 'без кэша'] +4. PostgreSQL заморожен (pause): запросы получают 503 в пределах общего срока, а не зависают + GET история -> 503 за 2.92 с OK + POST сообщение -> 503 за 2.01 с OK + неизвестный токен (не 200!) -> 503 за 2.00 с OK + вход по Basic -> 503 за 2.01 с OK + /health/ready -> 503 за 1.01 с OK + /health/live -> 200 за 0.00 с OK + готовность через 0.0 с после unpause; история: ['до отказа', 'без кэша'] PASS: отказы Valkey и PostgreSQL обработаны diff --git a/evidence/load.json b/evidence/load.json index 31e62f07..fa405cb8 100644 --- a/evidence/load.json +++ b/evidence/load.json @@ -2,16 +2,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.081, + "elapsed_seconds": 30.08, "concurrency": 4, - "successful_requests": 9296, + "successful_requests": 8513, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 309.032, + "successful_rps": 283.007, "successful_latency_ms": { - "p50": 10.443, - "p95": 30.846, - "p99": 34.768 + "p50": 11.961, + "p95": 32.043, + "p99": 36.317 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/persistence.txt b/evidence/persistence.txt index 5e0f2e69..a48fd3e8 100644 --- a/evidence/persistence.txt +++ b/evidence/persistence.txt @@ -1,39 +1,32 @@ # persistence: python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8080 -# date: 2026-10-29T09:19:40Z; base commit: 65003b6 (working tree, solution uncommitted); host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-11-06T09:35:18Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM $ docker compose ps -a (before) -SERVICE STATUS -api Up 26 minutes (healthy) -api-restore Exited (0) 37 seconds ago -migrate Exited (0) 27 minutes ago -postgres Up 26 minutes (healthy) -postgres-restore Up About a minute (healthy) -valkey Up 26 minutes (healthy) +SERVICE STATUS +api Up 18 seconds (healthy) +migrate Exited (0) 19 seconds ago +postgres Up 26 seconds (healthy) +valkey Up 26 seconds (healthy) Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. $ docker compose ps -a (after) -SERVICE STATUS -api Up 1 second (health: starting) -api-restore Exited (0) 48 seconds ago -migrate Exited (0) 2 seconds ago -postgres Up 9 seconds (healthy) -postgres-restore Up About a minute (healthy) -valkey Up 9 seconds (healthy) +SERVICE STATUS +api Up 1 second (health: starting) +migrate Exited (0) 1 second ago +postgres Up 8 seconds (healthy) +valkey Up 8 seconds (healthy) -$ docker compose logs --since 2026-10-29T09:19:40Z postgres valkey api | grep shutdown/ready lines -valkey-1 | 7:M 29 Oct 2026 09:19:42.428 * User requested shutdown... -valkey-1 | 7:M 29 Oct 2026 09:19:42.927 * Server initialized -valkey-1 | 7:M 29 Oct 2026 09:19:42.927 * Ready to accept connections tcp -api-1 | 2026-10-29 09:19:41,679 INFO messenger: application stopping -api-1 | 2026-10-29 09:19:51,290 INFO uvicorn.error: Waiting for application startup. -api-1 | 2026-10-29 09:19:51,293 INFO messenger: application started -postgres-1 | 2026-10-29 09:19:42.542 UTC [27] LOG: checkpoint complete: wrote 7023 buffers (42.9%); 0 WAL file(s) added, 0 removed, 5 recycled; write=0.118 s, -postgres-1 | 2026-10-29 09:19:42.592 UTC [1] LOG: database system is shut down -postgres-1 | 2026-10-29 09:19:43.092 UTC [29] LOG: database system was shut down at 2026-10-29 09:19:42 UTC -postgres-1 | 2026-10-29 09:19:43.101 UTC [1] LOG: database system is ready to accept connections +$ docker compose logs --since 2026-11-06T09:35:18Z postgres valkey api | shutdown/ready lines +valkey-1 | 7:M 06 Nov 2026 09:35:19.811 * User requested shutdown... +valkey-1 | 7:M 06 Nov 2026 09:35:20.228 * Ready to accept connections tcp +api-1 | 2026-11-06 09:35:19,146 INFO messenger: application stopping +api-1 | 2026-11-06 09:35:28,169 INFO uvicorn.error: Waiting for application startup. +api-1 | 2026-11-06 09:35:28,171 INFO messenger: application started +postgres-1 | 2026-11-06 09:35:19.812 UTC [1] LOG: database system is shut down +postgres-1 | 2026-11-06 09:35:20.286 UTC [29] LOG: database system was shut down at 2026-11-06 09:35:19 UTC +postgres-1 | 2026-11-06 09:35:20.291 UTC [1] LOG: database system is ready to accept connections $ docker volume ls (volumes kept) grigoriev-lab2_pgdata -grigoriev-lab2_pgdata_restore diff --git a/evidence/sigterm.txt b/evidence/sigterm.txt index 222749d1..301ab5ee 100644 --- a/evidence/sigterm.txt +++ b/evidence/sigterm.txt @@ -1,16 +1,21 @@ # python student-tests/sigterm_check.py; then docker compose start api -# date: 2026-10-29T09:21:28Z +# date: 2026-11-06T09:36:47Z сообщение с маркером отправлено: HTTP 201; маркер в логах: False -docker stop занял: 0.57 с (лимит 10 с) +docker stop занял: 0.48 с (лимит 10 с) код выхода контейнера: 0 (0 — сам завершился по SIGTERM; 137 — убит SIGKILL) -запросы до SIGTERM: 30, все 200: True -запросы после SIGTERM: 24, результаты: ['200', 'RemoteDisconnected', 'URLError'] +запросы до SIGTERM: 41, все 200: True +запросы после SIGTERM: 19, результаты: ['200', 'RemoteDisconnected', 'URLError'] ответов 5xx за всё время: 0 логи остановки: - 2026-10-29 09:21:29,562 INFO uvicorn.error: Shutting down - 2026-10-29 09:21:29,662 INFO uvicorn.error: Waiting for application shutdown. - 2026-10-29 09:21:29,662 INFO messenger: application stopping - 2026-10-29 09:21:29,663 INFO uvicorn.error: Application shutdown complete. - 2026-10-29 09:21:29,664 INFO uvicorn.error: Finished server process [1] + 2026-11-06 09:36:06,143 INFO uvicorn.error: Shutting down + 2026-11-06 09:36:06,244 INFO uvicorn.error: Waiting for application shutdown. + 2026-11-06 09:36:06,244 INFO messenger: application stopping + 2026-11-06 09:36:06,245 INFO uvicorn.error: Application shutdown complete. + 2026-11-06 09:36:06,245 INFO uvicorn.error: Finished server process [1] + 2026-11-06 09:36:48,504 INFO uvicorn.error: Shutting down + 2026-11-06 09:36:48,605 INFO uvicorn.error: Waiting for application shutdown. + 2026-11-06 09:36:48,605 INFO messenger: application stopping + 2026-11-06 09:36:48,606 INFO uvicorn.error: Application shutdown complete. + 2026-11-06 09:36:48,606 INFO uvicorn.error: Finished server process [1] diff --git a/evidence/smoke.txt b/evidence/smoke.txt index 42011687..fb6644cd 100644 --- a/evidence/smoke.txt +++ b/evidence/smoke.txt @@ -1,4 +1,4 @@ # python tests/smoke.py --base-url http://127.0.0.1:8080 -# date: 2026-10-31T07:28:38Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-11-06T09:35:17Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt index 255410ba..9ebf224f 100644 --- a/evidence/student-tests.txt +++ b/evidence/student-tests.txt @@ -1,5 +1,5 @@ # python -m unittest discover -s student-tests -v -# date: 2026-10-31T07:28:40Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-11-06T09:35:29Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM test_duplicate_username (test_api.DuplicateUsernameTest.test_duplicate_username) Повторная регистрация того же username -> 409 conflict ... ok @@ -19,8 +19,10 @@ test_outsider_cannot_write_or_read_history (test_api.ForeignChatTest.test_outsid Посторонний пишет/читает историю -> 404 ... ok test_outsider_does_not_see_chat_in_list (test_api.ForeignChatTest.test_outsider_does_not_see_chat_in_list) Чужой чат не попадает в список чатов ... ok -test_nul_character_is_rejected (test_api.IdentityTest.test_nul_character_is_rejected) -Символ NUL нельзя сохранить в PostgreSQL text -> 400, а не 500 ... ok +test_lone_surrogate_is_rejected (test_api.IdentityTest.test_lone_surrogate_is_rejected) +Одиночный суррогат не кодируется в UTF-8 -> 400, а не 500 ... ok +test_nul_character_is_preserved (test_api.IdentityTest.test_nul_character_is_preserved) +U+0000 — допустимый code point: сообщение, display_name и title сохраняются и читаются без изменений ... ok test_sender_cannot_be_forged (test_api.IdentityTest.test_sender_cannot_be_forged) sender_id в теле запрещён: отправитель только из сессии ... ok test_extra_field (test_api.InvalidJsonTest.test_extra_field) @@ -77,7 +79,7 @@ test_secrets_are_not_stored_in_plaintext (test_db.DatabaseTest.test_secrets_are_ В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен ... ok ---------------------------------------------------------------------- -Ran 37 tests in 19.926s +Ran 38 tests in 11.284s OK diff --git a/evidence/track2/planner_random_page_cost_1_1.json b/evidence/track2/planner_random_page_cost_1_1.json index 2855d9af..a73c5602 100644 --- a/evidence/track2/planner_random_page_cost_1_1.json +++ b/evidence/track2/planner_random_page_cost_1_1.json @@ -1,26 +1,26 @@ { "big_d50_offset": { - "median_ms": 11.508, - "p95_ms": 12.992, - "planning_ms": 0.061, - "shared_hit": 8064, + "median_ms": 12.147, + "p95_ms": 12.302, + "planning_ms": 0.069, + "shared_hit": 8065, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "big_d90_offset": { - "median_ms": 21.338, - "p95_ms": 21.923, - "planning_ms": 0.074, - "shared_hit": 14567, + "median_ms": 22.887, + "p95_ms": 23.85, + "planning_ms": 0.073, + "shared_hit": 14568, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "medium_d90_offset": { - "median_ms": 0.683, - "p95_ms": 0.728, - "planning_ms": 0.042, + "median_ms": 1.702, + "p95_ms": 2.26, + "planning_ms": 0.059, "shared_hit": 2499, "shared_read": 0, "rows": 51, diff --git a/evidence/track2/planner_random_page_cost_4.json b/evidence/track2/planner_random_page_cost_4.json index 9cb3aac4..1ba65f4b 100644 --- a/evidence/track2/planner_random_page_cost_4.json +++ b/evidence/track2/planner_random_page_cost_4.json @@ -1,27 +1,27 @@ { "big_d50_offset": { - "median_ms": 10.606, - "p95_ms": 11.549, - "planning_ms": 0.06, - "shared_hit": 8064, + "median_ms": 12.699, + "p95_ms": 13.438, + "planning_ms": 0.074, + "shared_hit": 8065, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "big_d90_offset": { - "median_ms": 120.438, - "p95_ms": 127.612, - "planning_ms": 0.085, - "shared_hit": 7865, - "shared_read": 4846, + "median_ms": 103.23, + "p95_ms": 113.371, + "planning_ms": 0.081, + "shared_hit": 12716, + "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_d90_offset": { - "median_ms": 5.041, - "p95_ms": 5.433, - "planning_ms": 0.055, - "shared_hit": 2713, + "median_ms": 4.908, + "p95_ms": 5.356, + "planning_ms": 0.062, + "shared_hit": 2867, "shared_read": 0, "rows": 51, "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(messages_chat_history_idx)" diff --git a/evidence/track2/reads.json b/evidence/track2/reads.json index cf070928..40b0668b 100644 --- a/evidence/track2/reads.json +++ b/evidence/track2/reads.json @@ -1,6 +1,6 @@ { "environment": { - "date": "2026-10-29T08:55:57Z", + "date": "2026-11-06T09:24:18Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", @@ -15,135 +15,135 @@ "index_bytes": 0, "queries": { "big_first": { - "median_ms": 31.636, - "p95_ms": 33.929, - "planning_ms": 0.068, + "median_ms": 29.855, + "p95_ms": 33.463, + "planning_ms": 0.07, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "big_d50_keyset": { - "median_ms": 29.115, - "p95_ms": 45.68, - "planning_ms": 0.083, + "median_ms": 27.84, + "p95_ms": 29.521, + "planning_ms": 0.086, "shared_hit": 12303, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "big_d50_offset": { - "median_ms": 116.405, - "p95_ms": 142.333, - "planning_ms": 0.074, + "median_ms": 82.726, + "p95_ms": 91.053, + "planning_ms": 0.071, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "big_d90_keyset": { - "median_ms": 25.118, - "p95_ms": 27.994, - "planning_ms": 0.078, + "median_ms": 24.206, + "p95_ms": 24.969, + "planning_ms": 0.081, "shared_hit": 12303, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "big_d90_offset": { - "median_ms": 135.534, - "p95_ms": 144.718, - "planning_ms": 0.074, + "median_ms": 95.196, + "p95_ms": 101.548, + "planning_ms": 0.073, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_first": { - "median_ms": 23.077, - "p95_ms": 23.909, - "planning_ms": 0.068, + "median_ms": 21.283, + "p95_ms": 22.359, + "planning_ms": 0.063, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_d50_keyset": { - "median_ms": 26.5, - "p95_ms": 31.003, - "planning_ms": 0.081, + "median_ms": 23.805, + "p95_ms": 24.848, + "planning_ms": 0.084, "shared_hit": 12303, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_d50_offset": { - "median_ms": 24.115, - "p95_ms": 26.148, - "planning_ms": 0.069, + "median_ms": 22.787, + "p95_ms": 24.114, + "planning_ms": 0.065, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_d90_keyset": { - "median_ms": 23.375, - "p95_ms": 25.052, - "planning_ms": 0.08, + "median_ms": 22.095, + "p95_ms": 23.473, + "planning_ms": 0.075, "shared_hit": 12303, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_d90_offset": { - "median_ms": 23.633, - "p95_ms": 24.813, - "planning_ms": 0.067, + "median_ms": 23.605, + "p95_ms": 25.903, + "planning_ms": 0.07, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "small_first": { - "median_ms": 20.085, - "p95_ms": 21.647, - "planning_ms": 0.064, + "median_ms": 20.489, + "p95_ms": 22.56, + "planning_ms": 0.066, "shared_hit": 12361, "shared_read": 0, "rows": 10, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "small_d50_keyset": { - "median_ms": 22.948, - "p95_ms": 25.171, - "planning_ms": 0.08, + "median_ms": 21.807, + "p95_ms": 23.296, + "planning_ms": 0.074, "shared_hit": 12273, "shared_read": 0, "rows": 5, "plan": "Limit > Sort > Gather > Seq Scan" }, "small_d50_offset": { - "median_ms": 21.521, - "p95_ms": 23.739, - "planning_ms": 0.066, + "median_ms": 20.635, + "p95_ms": 21.433, + "planning_ms": 0.065, "shared_hit": 12361, "shared_read": 0, "rows": 5, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "small_d90_keyset": { - "median_ms": 22.477, - "p95_ms": 25.176, - "planning_ms": 0.081, + "median_ms": 22.765, + "p95_ms": 24.006, + "planning_ms": 0.076, "shared_hit": 12273, "shared_read": 0, "rows": 1, "plan": "Limit > Sort > Gather > Seq Scan" }, "small_d90_offset": { - "median_ms": 22.451, - "p95_ms": 24.216, - "planning_ms": 0.068, + "median_ms": 20.671, + "p95_ms": 21.792, + "planning_ms": 0.065, "shared_hit": 12361, "shared_read": 0, "rows": 1, @@ -156,135 +156,135 @@ "index_bytes": 1572864, "queries": { "big_first": { - "median_ms": 29.135, - "p95_ms": 34.976, - "planning_ms": 0.077, + "median_ms": 28.506, + "p95_ms": 29.773, + "planning_ms": 0.074, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "big_d50_keyset": { - "median_ms": 28.754, - "p95_ms": 30.474, - "planning_ms": 0.093, + "median_ms": 26.492, + "p95_ms": 28.799, + "planning_ms": 0.095, "shared_hit": 12303, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "big_d50_offset": { - "median_ms": 114.655, - "p95_ms": 118.28, - "planning_ms": 0.081, + "median_ms": 86.904, + "p95_ms": 89.746, + "planning_ms": 0.079, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "big_d90_keyset": { - "median_ms": 25.87, - "p95_ms": 28.291, - "planning_ms": 0.088, + "median_ms": 24.488, + "p95_ms": 25.492, + "planning_ms": 0.085, "shared_hit": 12303, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "big_d90_offset": { - "median_ms": 130.247, - "p95_ms": 139.705, - "planning_ms": 0.086, + "median_ms": 99.044, + "p95_ms": 102.717, + "planning_ms": 0.08, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_first": { - "median_ms": 3.504, - "p95_ms": 3.65, - "planning_ms": 0.058, - "shared_hit": 2695, + "median_ms": 2.821, + "p95_ms": 3.308, + "planning_ms": 0.052, + "shared_hit": 2694, "shared_read": 0, "rows": 51, "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" }, "medium_d50_keyset": { - "median_ms": 3.528, - "p95_ms": 4.512, - "planning_ms": 0.073, - "shared_hit": 2695, + "median_ms": 3.69, + "p95_ms": 3.892, + "planning_ms": 0.074, + "shared_hit": 2694, "shared_read": 0, "rows": 51, "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" }, "medium_d50_offset": { - "median_ms": 6.258, - "p95_ms": 6.974, - "planning_ms": 0.071, - "shared_hit": 2695, + "median_ms": 5.17, + "p95_ms": 5.732, + "planning_ms": 0.068, + "shared_hit": 2694, "shared_read": 0, "rows": 51, "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" }, "medium_d90_keyset": { - "median_ms": 3.442, - "p95_ms": 4.265, - "planning_ms": 0.076, - "shared_hit": 2695, + "median_ms": 3.184, + "p95_ms": 3.875, + "planning_ms": 0.069, + "shared_hit": 2694, "shared_read": 0, "rows": 51, "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" }, "medium_d90_offset": { - "median_ms": 6.063, - "p95_ms": 6.213, - "planning_ms": 0.061, - "shared_hit": 2695, + "median_ms": 5.065, + "p95_ms": 5.217, + "planning_ms": 0.059, + "shared_hit": 2694, "shared_read": 0, "rows": 51, "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)" }, "small_first": { - "median_ms": 0.061, - "p95_ms": 0.064, - "planning_ms": 0.041, + "median_ms": 0.057, + "p95_ms": 0.093, + "planning_ms": 0.048, "shared_hit": 13, "shared_read": 0, "rows": 10, "plan": "Limit > Sort > Index Scan(bench_chat_idx)" }, "small_d50_keyset": { - "median_ms": 0.064, - "p95_ms": 0.098, - "planning_ms": 0.05, + "median_ms": 0.046, + "p95_ms": 0.065, + "planning_ms": 0.046, "shared_hit": 13, "shared_read": 0, "rows": 5, "plan": "Limit > Sort > Index Scan(bench_chat_idx)" }, "small_d50_offset": { - "median_ms": 0.079, - "p95_ms": 0.1, - "planning_ms": 0.044, + "median_ms": 0.044, + "p95_ms": 0.05, + "planning_ms": 0.04, "shared_hit": 13, "shared_read": 0, "rows": 5, "plan": "Limit > Sort > Index Scan(bench_chat_idx)" }, "small_d90_keyset": { - "median_ms": 0.067, - "p95_ms": 0.108, - "planning_ms": 0.05, + "median_ms": 0.058, + "p95_ms": 0.089, + "planning_ms": 0.058, "shared_hit": 13, "shared_read": 0, "rows": 1, "plan": "Limit > Sort > Index Scan(bench_chat_idx)" }, "small_d90_offset": { - "median_ms": 0.087, - "p95_ms": 0.116, - "planning_ms": 0.055, + "median_ms": 0.047, + "p95_ms": 0.056, + "planning_ms": 0.04, "shared_hit": 13, "shared_read": 0, "rows": 1, @@ -293,57 +293,57 @@ } }, "created_at_id": { - "build_seconds": 0.48, + "build_seconds": 0.42, "index_bytes": 8126464, "queries": { "big_first": { - "median_ms": 0.055, - "p95_ms": 0.078, - "planning_ms": 0.026, + "median_ms": 0.066, + "p95_ms": 0.115, + "planning_ms": 0.033, "shared_hit": 9, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(bench_time_idx)" }, "big_d50_keyset": { - "median_ms": 0.056, - "p95_ms": 0.063, - "planning_ms": 0.05, + "median_ms": 0.059, + "p95_ms": 0.088, + "planning_ms": 0.058, "shared_hit": 18, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(bench_time_idx)" }, "big_d50_offset": { - "median_ms": 22.942, - "p95_ms": 23.121, - "planning_ms": 0.053, + "median_ms": 23.172, + "p95_ms": 24.77, + "planning_ms": 0.056, "shared_hit": 9806, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(bench_time_idx)" }, "big_d90_keyset": { - "median_ms": 0.057, - "p95_ms": 0.077, - "planning_ms": 0.053, + "median_ms": 0.053, + "p95_ms": 0.086, + "planning_ms": 0.052, "shared_hit": 17, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(bench_time_idx)" }, "big_d90_offset": { - "median_ms": 41.109, - "p95_ms": 41.439, - "planning_ms": 0.064, + "median_ms": 42.03, + "p95_ms": 42.737, + "planning_ms": 0.056, "shared_hit": 17650, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(bench_time_idx)" }, "medium_first": { - "median_ms": 0.349, - "p95_ms": 0.378, + "median_ms": 0.351, + "p95_ms": 0.411, "planning_ms": 0.025, "shared_hit": 327, "shared_read": 0, @@ -351,17 +351,17 @@ "plan": "Limit > Index Scan(bench_time_idx)" }, "medium_d50_keyset": { - "median_ms": 0.419, - "p95_ms": 0.49, - "planning_ms": 0.049, + "median_ms": 0.431, + "p95_ms": 0.508, + "planning_ms": 0.047, "shared_hit": 375, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(bench_time_idx)" }, "medium_d50_offset": { - "median_ms": 23.305, - "p95_ms": 24.069, + "median_ms": 21.222, + "p95_ms": 23.522, "planning_ms": 0.074, "shared_hit": 12361, "shared_read": 0, @@ -369,63 +369,63 @@ "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_d90_keyset": { - "median_ms": 0.354, - "p95_ms": 0.399, - "planning_ms": 0.05, + "median_ms": 0.371, + "p95_ms": 0.45, + "planning_ms": 0.046, "shared_hit": 314, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(bench_time_idx)" }, "medium_d90_offset": { - "median_ms": 23.641, - "p95_ms": 24.668, - "planning_ms": 0.075, + "median_ms": 21.646, + "p95_ms": 23.229, + "planning_ms": 0.072, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "small_first": { - "median_ms": 21.749, - "p95_ms": 22.376, - "planning_ms": 0.078, + "median_ms": 20.97, + "p95_ms": 21.726, + "planning_ms": 0.074, "shared_hit": 12361, "shared_read": 0, "rows": 10, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "small_d50_keyset": { - "median_ms": 24.374, - "p95_ms": 25.062, - "planning_ms": 0.092, + "median_ms": 22.362, + "p95_ms": 23.698, + "planning_ms": 0.086, "shared_hit": 12273, "shared_read": 0, "rows": 5, "plan": "Limit > Sort > Gather > Seq Scan" }, "small_d50_offset": { - "median_ms": 21.753, - "p95_ms": 22.948, - "planning_ms": 0.078, + "median_ms": 20.795, + "p95_ms": 22.545, + "planning_ms": 0.079, "shared_hit": 12361, "shared_read": 0, "rows": 5, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "small_d90_keyset": { - "median_ms": 0.824, - "p95_ms": 1.122, - "planning_ms": 0.055, + "median_ms": 0.606, + "p95_ms": 1.147, + "planning_ms": 0.052, "shared_hit": 548, "shared_read": 0, "rows": 1, "plan": "Limit > Index Scan(bench_time_idx)" }, "small_d90_offset": { - "median_ms": 20.675, - "p95_ms": 23.105, - "planning_ms": 0.078, + "median_ms": 20.988, + "p95_ms": 22.671, + "planning_ms": 0.075, "shared_hit": 12361, "shared_read": 0, "rows": 1, @@ -434,139 +434,139 @@ } }, "chat_created_id": { - "build_seconds": 0.53, + "build_seconds": 0.45, "index_bytes": 11796480, "queries": { "big_first": { - "median_ms": 0.057, - "p95_ms": 0.07, - "planning_ms": 0.049, + "median_ms": 0.041, + "p95_ms": 0.062, + "planning_ms": 0.043, "shared_hit": 9, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "big_d50_keyset": { - "median_ms": 0.048, - "p95_ms": 0.076, - "planning_ms": 0.054, + "median_ms": 0.044, + "p95_ms": 0.054, + "planning_ms": 0.05, "shared_hit": 13, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "big_d50_offset": { - "median_ms": 11.673, - "p95_ms": 12.276, - "planning_ms": 0.061, + "median_ms": 12.13, + "p95_ms": 12.453, + "planning_ms": 0.069, "shared_hit": 8064, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "big_d90_keyset": { - "median_ms": 0.054, - "p95_ms": 0.073, - "planning_ms": 0.053, + "median_ms": 0.074, + "p95_ms": 0.148, + "planning_ms": 0.086, "shared_hit": 11, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "big_d90_offset": { - "median_ms": 132.109, - "p95_ms": 137.947, - "planning_ms": 0.085, + "median_ms": 122.989, + "p95_ms": 182.894, + "planning_ms": 0.105, "shared_hit": 12361, "shared_read": 0, "rows": 51, "plan": "Limit > Gather Merge > Sort > Seq Scan" }, "medium_first": { - "median_ms": 0.051, - "p95_ms": 0.072, - "planning_ms": 0.041, - "shared_hit": 50, + "median_ms": 0.073, + "p95_ms": 0.087, + "planning_ms": 0.053, + "shared_hit": 51, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "medium_d50_keyset": { - "median_ms": 0.056, - "p95_ms": 0.093, - "planning_ms": 0.052, + "median_ms": 0.07, + "p95_ms": 0.104, + "planning_ms": 0.059, "shared_hit": 48, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "medium_d50_offset": { - "median_ms": 0.43, - "p95_ms": 0.472, - "planning_ms": 0.04, + "median_ms": 0.999, + "p95_ms": 1.258, + "planning_ms": 0.063, "shared_hit": 1408, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "medium_d90_keyset": { - "median_ms": 0.057, - "p95_ms": 0.085, - "planning_ms": 0.05, + "median_ms": 0.067, + "p95_ms": 0.103, + "planning_ms": 0.076, "shared_hit": 49, "shared_read": 0, "rows": 51, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "medium_d90_offset": { - "median_ms": 5.539, - "p95_ms": 6.149, - "planning_ms": 0.058, - "shared_hit": 2713, + "median_ms": 6.129, + "p95_ms": 7.569, + "planning_ms": 0.081, + "shared_hit": 2714, "shared_read": 0, "rows": 51, "plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(messages_chat_history_idx)" }, "small_first": { - "median_ms": 0.039, - "p95_ms": 0.059, - "planning_ms": 0.039, + "median_ms": 0.037, + "p95_ms": 0.05, + "planning_ms": 0.048, "shared_hit": 13, "shared_read": 0, "rows": 10, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "small_d50_keyset": { - "median_ms": 0.05, - "p95_ms": 0.069, - "planning_ms": 0.065, + "median_ms": 0.054, + "p95_ms": 0.065, + "planning_ms": 0.071, "shared_hit": 8, "shared_read": 0, "rows": 5, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "small_d50_offset": { - "median_ms": 0.038, - "p95_ms": 0.049, - "planning_ms": 0.041, + "median_ms": 0.036, + "p95_ms": 0.054, + "planning_ms": 0.044, "shared_hit": 13, "shared_read": 0, "rows": 5, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "small_d90_keyset": { - "median_ms": 0.038, - "p95_ms": 0.069, - "planning_ms": 0.054, + "median_ms": 0.047, + "p95_ms": 0.099, + "planning_ms": 0.069, "shared_hit": 4, "shared_read": 0, "rows": 1, "plan": "Limit > Index Scan(messages_chat_history_idx)" }, "small_d90_offset": { - "median_ms": 0.046, - "p95_ms": 0.073, - "planning_ms": 0.054, + "median_ms": 0.038, + "p95_ms": 0.049, + "planning_ms": 0.049, "shared_hit": 13, "shared_read": 0, "rows": 1, diff --git a/evidence/track2/restore.json b/evidence/track2/restore.json index 3712855d..8d59aca2 100644 --- a/evidence/track2/restore.json +++ b/evidence/track2/restore.json @@ -1,49 +1,49 @@ { "environment": { - "date": "2026-10-29T09:19:01Z", + "date": "2026-11-06T09:33:39Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB" }, - "dump_bytes": 14099013, + "dump_bytes": 15031377, "times_seconds": { - "dump_bench": 1.69, - "dump_messenger": 0.51, + "dump_bench": 1.89, + "dump_messenger": 0.45, "copy": 1.52, - "restore_bench": 2.36, - "restore_messenger": 0.42, - "analyze": 0.74, - "api_restore_ready": 6.74 + "restore_bench": 2.11, + "restore_messenger": 0.4, + "analyze": 0.67, + "api_restore_ready": 6.66 }, - "rto_seconds": 13.98, + "rto_seconds": 13.7, "source": { "users": "1000", "chats": "4021", "chat_members": "8600", "messages": "200000", - "all_messages_md5": "f3e491b7ebfb52972c8ee73470a90926", - "big_first_page_md5": "516a32c3f0dce2566e84161528ea595c", - "big_d90_page_md5": "52b8761a011eae861bb3518ea2685698", - "small_chat_md5": "cd1b0184a9133cc7f0f688ab21b713d9" + "all_messages_md5": "8b73772737bfac55f58fcb44bb7cf76b", + "big_first_page_md5": "dc073bfb1f81a079c2213518ba3892a3", + "big_d90_page_md5": "aad19d2102ee255431bf6eb01e46ed30", + "small_chat_md5": "0003ec25c51fc6f6d025c469ab5ca302" }, "restored": { "users": "1000", "chats": "4021", "chat_members": "8600", "messages": "200000", - "all_messages_md5": "f3e491b7ebfb52972c8ee73470a90926", - "big_first_page_md5": "516a32c3f0dce2566e84161528ea595c", - "big_d90_page_md5": "52b8761a011eae861bb3518ea2685698", - "small_chat_md5": "cd1b0184a9133cc7f0f688ab21b713d9" + "all_messages_md5": "8b73772737bfac55f58fcb44bb7cf76b", + "big_first_page_md5": "dc073bfb1f81a079c2213518ba3892a3", + "big_d90_page_md5": "aad19d2102ee255431bf6eb01e46ed30", + "small_chat_md5": "0003ec25c51fc6f6d025c469ab5ca302" }, "mismatches": [], "concurrent_writes": { - "committed_before_dump_start": 3787, - "committed_total": 11172, - "present_in_backup": 4482, - "lost_after_snapshot": 6690 + "committed_before_dump_start": 3694, + "committed_total": 11219, + "present_in_backup": 4329, + "lost_after_snapshot": 6890 }, "api_restore": { "old_token_users_me": 200, diff --git a/evidence/track2/results.md b/evidence/track2/results.md index 97c87601..3ebc36c1 100644 --- a/evidence/track2/results.md +++ b/evidence/track2/results.md @@ -1,26 +1,26 @@ # Трек 2: результаты -Среда: `{"date": "2026-10-29T08:55:57Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB"}` +Среда: `{"date": "2026-11-06T09:24:18Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB"}` ## Чтение страницы истории (LIMIT 51), медиана из 15 прогонов, мс | запрос | pk_only | chat_id | created_at_id | chat_created_id | |---|---|---|---|---| -| big_first | 31.636 | 29.135 | 0.055 | 0.057 | -| big_d50_keyset | 29.115 | 28.754 | 0.056 | 0.048 | -| big_d50_offset | 116.405 | 114.655 | 22.942 | 11.673 | -| big_d90_keyset | 25.118 | 25.870 | 0.057 | 0.054 | -| big_d90_offset | 135.534 | 130.247 | 41.109 | 132.109 | -| medium_first | 23.077 | 3.504 | 0.349 | 0.051 | -| medium_d50_keyset | 26.500 | 3.528 | 0.419 | 0.056 | -| medium_d50_offset | 24.115 | 6.258 | 23.305 | 0.430 | -| medium_d90_keyset | 23.375 | 3.442 | 0.354 | 0.057 | -| medium_d90_offset | 23.633 | 6.063 | 23.641 | 5.539 | -| small_first | 20.085 | 0.061 | 21.749 | 0.039 | -| small_d50_keyset | 22.948 | 0.064 | 24.374 | 0.050 | -| small_d50_offset | 21.521 | 0.079 | 21.753 | 0.038 | -| small_d90_keyset | 22.477 | 0.067 | 0.824 | 0.038 | -| small_d90_offset | 22.451 | 0.087 | 20.675 | 0.046 | +| big_first | 29.855 | 28.506 | 0.066 | 0.041 | +| big_d50_keyset | 27.840 | 26.492 | 0.059 | 0.044 | +| big_d50_offset | 82.726 | 86.904 | 23.172 | 12.130 | +| big_d90_keyset | 24.206 | 24.488 | 0.053 | 0.074 | +| big_d90_offset | 95.196 | 99.044 | 42.030 | 122.989 | +| medium_first | 21.283 | 2.821 | 0.351 | 0.073 | +| medium_d50_keyset | 23.805 | 3.690 | 0.431 | 0.070 | +| medium_d50_offset | 22.787 | 5.170 | 21.222 | 0.999 | +| medium_d90_keyset | 22.095 | 3.184 | 0.371 | 0.067 | +| medium_d90_offset | 23.605 | 5.065 | 21.646 | 6.129 | +| small_first | 20.489 | 0.057 | 20.970 | 0.037 | +| small_d50_keyset | 21.807 | 0.046 | 22.362 | 0.054 | +| small_d50_offset | 20.635 | 0.044 | 20.795 | 0.036 | +| small_d90_keyset | 22.765 | 0.058 | 0.606 | 0.047 | +| small_d90_offset | 20.671 | 0.047 | 20.988 | 0.038 | ## Буферы (shared hit + read) на запрос @@ -31,11 +31,11 @@ | big_d50_offset | 12361 | 12361 | 9806 | 8064 | | big_d90_keyset | 12303 | 12303 | 17 | 11 | | big_d90_offset | 12361 | 12361 | 17650 | 12361 | -| medium_first | 12361 | 2695 | 327 | 50 | -| medium_d50_keyset | 12303 | 2695 | 375 | 48 | -| medium_d50_offset | 12361 | 2695 | 12361 | 1408 | -| medium_d90_keyset | 12303 | 2695 | 314 | 49 | -| medium_d90_offset | 12361 | 2695 | 12361 | 2713 | +| medium_first | 12361 | 2694 | 327 | 51 | +| medium_d50_keyset | 12303 | 2694 | 375 | 48 | +| medium_d50_offset | 12361 | 2694 | 12361 | 1408 | +| medium_d90_keyset | 12303 | 2694 | 314 | 49 | +| medium_d90_offset | 12361 | 2694 | 12361 | 2714 | | small_first | 12361 | 13 | 12361 | 13 | | small_d50_keyset | 12273 | 13 | 12273 | 8 | | small_d50_offset | 12361 | 13 | 12361 | 13 | @@ -67,8 +67,8 @@ |---|---|---| | pk_only | 0.0 | 0.00 | | chat_id | 1.5 | 0.43 | -| created_at_id | 7.8 | 0.48 | -| chat_created_id | 11.2 | 0.53 | +| created_at_id | 7.8 | 0.42 | +| chat_created_id | 11.2 | 0.45 | ## Запись @@ -76,27 +76,27 @@ | вариант | INSERT (таблица+индексы), мс/1000 | FK-проверка, мс/1000 | всего, мс/1000 | WAL на строку, байт | pgbench TPS медиана [min..max] | latency, мс | |---|---|---|---|---|---|---| -| pk_only | 9.80 | 31.30 | 41.46 | 2793 | 784.2 [528.9..3583.6] | 5.101 | -| chat_id | 11.24 | 30.13 | 41.14 | 2951 | 3541.4 [2776.1..3601.4] | 1.129 | -| created_at_id | 10.85 | 30.81 | 41.22 | 2877 | 3491.3 [3477.0..3522.1] | 1.146 | -| chat_created_id | 11.79 | 31.32 | 43.23 | 3036 | 3505.2 [2773.7..3540.0] | 1.141 | -| chat_created_id_plus_time | 12.78 | 30.83 | 44.16 | 3121 | 3552.6 [783.2..3578.8] | 1.126 | +| pk_only | 9.70 | 20.89 | 30.69 | 2792 | 628.2 [419.8..3444.1] | 6.368 | +| chat_id | 10.18 | 22.02 | 33.45 | 2950 | 3483.3 [2960.9..3663.6] | 1.148 | +| created_at_id | 8.60 | 21.01 | 29.57 | 2877 | 790.1 [489.5..3691.3] | 5.062 | +| chat_created_id | 10.71 | 19.87 | 31.03 | 3035 | 3376.1 [2738.2..3602.6] | 1.185 | +| chat_created_id_plus_time | 11.44 | 20.48 | 32.02 | 3120 | 3566.2 [2642.9..3650.8] | 1.122 | ## Backup -> restore | этап | секунд | |---|---| -| dump_bench | 1.69 | -| dump_messenger | 0.51 | +| dump_bench | 1.89 | +| dump_messenger | 0.45 | | copy | 1.52 | -| restore_bench | 2.36 | -| restore_messenger | 0.42 | -| analyze | 0.74 | -| api_restore_ready | 6.74 | -| **итого (RTO на этом стенде)** | **13.98** | +| restore_bench | 2.11 | +| restore_messenger | 0.40 | +| analyze | 0.67 | +| api_restore_ready | 6.66 | +| **итого (RTO на этом стенде)** | **13.70** | -Размер bench.dump: 13.4 MiB. Несовпадения контрольных сумм: нет. -Запись во время дампа: {"committed_before_dump_start": 3787, "committed_total": 11172, "present_in_backup": 4482, "lost_after_snapshot": 6690}. +Размер bench.dump: 14.3 MiB. Несовпадения контрольных сумм: нет. +Запись во время дампа: {"committed_before_dump_start": 3694, "committed_total": 11219, "present_in_backup": 4329, "lost_after_snapshot": 6890}. API на восстановленной БД: {"old_token_users_me": 200, "message_matches": true}. | проверка | источник | восстановлено | @@ -105,7 +105,7 @@ API на восстановленной БД: {"old_token_users_me": 200, "messa | chats | `4021` | `4021` | | chat_members | `8600` | `8600` | | messages | `200000` | `200000` | -| all_messages_md5 | `f3e491b7ebfb52972c8ee73470a90926` | `f3e491b7ebfb52972c8ee73470a90926` | -| big_first_page_md5 | `516a32c3f0dce2566e84161528ea595c` | `516a32c3f0dce2566e84161528ea595c` | -| big_d90_page_md5 | `52b8761a011eae861bb3518ea2685698` | `52b8761a011eae861bb3518ea2685698` | -| small_chat_md5 | `cd1b0184a9133cc7f0f688ab21b713d9` | `cd1b0184a9133cc7f0f688ab21b713d9` | +| all_messages_md5 | `8b73772737bfac55f58fcb44bb7cf76b` | `8b73772737bfac55f58fcb44bb7cf76b` | +| big_first_page_md5 | `dc073bfb1f81a079c2213518ba3892a3` | `dc073bfb1f81a079c2213518ba3892a3` | +| big_d90_page_md5 | `aad19d2102ee255431bf6eb01e46ed30` | `aad19d2102ee255431bf6eb01e46ed30` | +| small_chat_md5 | `0003ec25c51fc6f6d025c469ab5ca302` | `0003ec25c51fc6f6d025c469ab5ca302` | diff --git a/evidence/track2/writes.json b/evidence/track2/writes.json index a71e9fc8..c4dbbadb 100644 --- a/evidence/track2/writes.json +++ b/evidence/track2/writes.json @@ -1,6 +1,6 @@ { "environment": { - "date": "2026-10-29T09:10:50Z", + "date": "2026-11-06T09:25:09Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", @@ -13,372 +13,372 @@ "bulk_rows": 20000, "variants": { "pk_only": { - "bulk_insert_ms_per_1000": 9.8, - "bulk_fk_ms_per_1000": 31.3, - "bulk_total_ms_per_1000": 41.46, - "bulk_wal_bytes_per_row": 2793, - "tps_median": 784.2, - "tps_min": 528.9, - "tps_max": 3583.6, - "latency_ms_median": 5.101, + "bulk_insert_ms_per_1000": 9.7, + "bulk_fk_ms_per_1000": 20.89, + "bulk_total_ms_per_1000": 30.69, + "bulk_wal_bytes_per_row": 2792, + "tps_median": 628.2, + "tps_min": 419.8, + "tps_max": 3444.1, + "latency_ms_median": 6.368, "bulks": [ { - "insert_ms_per_1000": 9.8, - "fk_ms_per_1000": 31.52, - "total_ms_per_1000": 41.47, - "wal_bytes_per_row": 2793 + "insert_ms_per_1000": 10.31, + "fk_ms_per_1000": 23.74, + "total_ms_per_1000": 34.15, + "wal_bytes_per_row": 2801 }, { - "insert_ms_per_1000": 11.09, - "fk_ms_per_1000": 30.56, - "total_ms_per_1000": 41.76, - "wal_bytes_per_row": 2793 + "insert_ms_per_1000": 9.07, + "fk_ms_per_1000": 21.88, + "total_ms_per_1000": 31.03, + "wal_bytes_per_row": 2794 }, { - "insert_ms_per_1000": 9.43, - "fk_ms_per_1000": 31.91, - "total_ms_per_1000": 41.46, - "wal_bytes_per_row": 2793 + "insert_ms_per_1000": 10.53, + "fk_ms_per_1000": 19.61, + "total_ms_per_1000": 30.23, + "wal_bytes_per_row": 2792 }, { - "insert_ms_per_1000": 9.95, - "fk_ms_per_1000": 31.3, - "total_ms_per_1000": 41.36, - "wal_bytes_per_row": 2793 + "insert_ms_per_1000": 9.7, + "fk_ms_per_1000": 20.89, + "total_ms_per_1000": 30.69, + "wal_bytes_per_row": 2792 }, { - "insert_ms_per_1000": 9.5, - "fk_ms_per_1000": 30.65, - "total_ms_per_1000": 40.27, - "wal_bytes_per_row": 2793 + "insert_ms_per_1000": 8.52, + "fk_ms_per_1000": 20.4, + "total_ms_per_1000": 29.02, + "wal_bytes_per_row": 2792 } ], "attempts": [ { - "tps": 3513.544906, - "latency_ms": 1.138, - "transactions": 35120, - "wal_bytes_per_insert": 1769 + "tps": 626.912498, + "latency_ms": 6.38, + "transactions": 6272, + "wal_bytes_per_insert": 7237 }, { - "tps": 3583.592907, - "latency_ms": 1.116, - "transactions": 35820, - "wal_bytes_per_insert": 1741 + "tps": 628.18138, + "latency_ms": 6.368, + "transactions": 6286, + "wal_bytes_per_insert": 7237 }, { - "tps": 784.216324, - "latency_ms": 5.101, - "transactions": 7843, - "wal_bytes_per_insert": 6893 + "tps": 419.785035, + "latency_ms": 9.529, + "transactions": 4201, + "wal_bytes_per_insert": 7728 }, { - "tps": 661.032239, - "latency_ms": 6.051, - "transactions": 6616, - "wal_bytes_per_insert": 7164 + "tps": 2755.410642, + "latency_ms": 1.452, + "transactions": 27546, + "wal_bytes_per_insert": 2175 }, { - "tps": 528.938348, - "latency_ms": 7.562, - "transactions": 5289, - "wal_bytes_per_insert": 7348 + "tps": 3444.121974, + "latency_ms": 1.161, + "transactions": 34429, + "wal_bytes_per_insert": 1801 } ] }, "chat_id": { - "bulk_insert_ms_per_1000": 11.24, - "bulk_fk_ms_per_1000": 30.13, - "bulk_total_ms_per_1000": 41.14, - "bulk_wal_bytes_per_row": 2951, - "tps_median": 3541.4, - "tps_min": 2776.1, - "tps_max": 3601.4, - "latency_ms_median": 1.129, + "bulk_insert_ms_per_1000": 10.18, + "bulk_fk_ms_per_1000": 22.02, + "bulk_total_ms_per_1000": 33.45, + "bulk_wal_bytes_per_row": 2950, + "tps_median": 3483.3, + "tps_min": 2960.9, + "tps_max": 3663.6, + "latency_ms_median": 1.148, "bulks": [ { - "insert_ms_per_1000": 11.24, - "fk_ms_per_1000": 30.74, - "total_ms_per_1000": 42.09, - "wal_bytes_per_row": 2946 + "insert_ms_per_1000": 10.32, + "fk_ms_per_1000": 23.03, + "total_ms_per_1000": 33.45, + "wal_bytes_per_row": 2945 }, { - "insert_ms_per_1000": 11.26, - "fk_ms_per_1000": 29.76, - "total_ms_per_1000": 41.14, - "wal_bytes_per_row": 2954 + "insert_ms_per_1000": 11.41, + "fk_ms_per_1000": 22.02, + "total_ms_per_1000": 33.52, + "wal_bytes_per_row": 2957 }, { - "insert_ms_per_1000": 10.71, - "fk_ms_per_1000": 30.13, - "total_ms_per_1000": 40.95, - "wal_bytes_per_row": 2951 + "insert_ms_per_1000": 9.36, + "fk_ms_per_1000": 24.61, + "total_ms_per_1000": 34.06, + "wal_bytes_per_row": 2947 }, { - "insert_ms_per_1000": 11.43, - "fk_ms_per_1000": 30.85, - "total_ms_per_1000": 42.4, - "wal_bytes_per_row": 2951 + "insert_ms_per_1000": 9.9, + "fk_ms_per_1000": 21.2, + "total_ms_per_1000": 31.19, + "wal_bytes_per_row": 2950 }, { - "insert_ms_per_1000": 11.08, - "fk_ms_per_1000": 29.95, - "total_ms_per_1000": 41.14, + "insert_ms_per_1000": 10.18, + "fk_ms_per_1000": 19.36, + "total_ms_per_1000": 29.63, "wal_bytes_per_row": 2954 } ], "attempts": [ { - "tps": 3526.596885, - "latency_ms": 1.134, - "transactions": 35252, - "wal_bytes_per_insert": 1896 + "tps": 3483.270409, + "latency_ms": 1.148, + "transactions": 34822, + "wal_bytes_per_insert": 1914 }, { - "tps": 3541.427104, - "latency_ms": 1.129, - "transactions": 35402, - "wal_bytes_per_insert": 1887 + "tps": 3562.57173, + "latency_ms": 1.123, + "transactions": 35614, + "wal_bytes_per_insert": 1879 }, { - "tps": 3552.604368, - "latency_ms": 1.126, - "transactions": 35508, - "wal_bytes_per_insert": 1885 + "tps": 2960.857014, + "latency_ms": 1.351, + "transactions": 29602, + "wal_bytes_per_insert": 2186 }, { - "tps": 3601.44502, - "latency_ms": 1.111, - "transactions": 35996, - "wal_bytes_per_insert": 1866 + "tps": 3355.068589, + "latency_ms": 1.192, + "transactions": 33540, + "wal_bytes_per_insert": 1976 }, { - "tps": 2776.112606, - "latency_ms": 1.441, - "transactions": 27749, - "wal_bytes_per_insert": 2310 + "tps": 3663.575244, + "latency_ms": 1.092, + "transactions": 36626, + "wal_bytes_per_insert": 1845 } ] }, "created_at_id": { - "bulk_insert_ms_per_1000": 10.85, - "bulk_fk_ms_per_1000": 30.81, - "bulk_total_ms_per_1000": 41.22, + "bulk_insert_ms_per_1000": 8.6, + "bulk_fk_ms_per_1000": 21.01, + "bulk_total_ms_per_1000": 29.57, "bulk_wal_bytes_per_row": 2877, - "tps_median": 3491.3, - "tps_min": 3477.0, - "tps_max": 3522.1, - "latency_ms_median": 1.146, + "tps_median": 790.1, + "tps_min": 489.5, + "tps_max": 3691.3, + "latency_ms_median": 5.062, "bulks": [ { - "insert_ms_per_1000": 10.85, - "fk_ms_per_1000": 30.26, - "total_ms_per_1000": 41.22, + "insert_ms_per_1000": 8.6, + "fk_ms_per_1000": 19.84, + "total_ms_per_1000": 28.53, "wal_bytes_per_row": 2877 }, { - "insert_ms_per_1000": 10.84, - "fk_ms_per_1000": 30.82, - "total_ms_per_1000": 41.78, + "insert_ms_per_1000": 9.11, + "fk_ms_per_1000": 22.48, + "total_ms_per_1000": 31.68, "wal_bytes_per_row": 2877 }, { - "insert_ms_per_1000": 11.47, - "fk_ms_per_1000": 30.81, - "total_ms_per_1000": 42.39, + "insert_ms_per_1000": 8.19, + "fk_ms_per_1000": 21.01, + "total_ms_per_1000": 29.28, "wal_bytes_per_row": 2877 }, { - "insert_ms_per_1000": 10.89, - "fk_ms_per_1000": 30.13, - "total_ms_per_1000": 41.12, + "insert_ms_per_1000": 8.73, + "fk_ms_per_1000": 20.75, + "total_ms_per_1000": 29.57, "wal_bytes_per_row": 2877 }, { - "insert_ms_per_1000": 9.92, - "fk_ms_per_1000": 30.84, - "total_ms_per_1000": 40.88, + "insert_ms_per_1000": 8.48, + "fk_ms_per_1000": 21.36, + "total_ms_per_1000": 29.93, "wal_bytes_per_row": 2877 } ], "attempts": [ { - "tps": 3522.068729, - "latency_ms": 1.136, - "transactions": 35205, - "wal_bytes_per_insert": 1850 + "tps": 3589.868099, + "latency_ms": 1.114, + "transactions": 35885, + "wal_bytes_per_insert": 1823 }, { - "tps": 3476.990375, - "latency_ms": 1.15, - "transactions": 34754, - "wal_bytes_per_insert": 1869 + "tps": 3691.258686, + "latency_ms": 1.084, + "transactions": 36901, + "wal_bytes_per_insert": 1783 }, { - "tps": 3491.314235, - "latency_ms": 1.146, - "transactions": 34896, - "wal_bytes_per_insert": 1864 + "tps": 790.148226, + "latency_ms": 5.062, + "transactions": 7905, + "wal_bytes_per_insert": 6927 }, { - "tps": 3486.483623, - "latency_ms": 1.147, - "transactions": 34848, - "wal_bytes_per_insert": 1866 + "tps": 517.000669, + "latency_ms": 7.737, + "transactions": 5204, + "wal_bytes_per_insert": 7432 }, { - "tps": 3517.088554, - "latency_ms": 1.137, - "transactions": 35154, - "wal_bytes_per_insert": 1854 + "tps": 489.540276, + "latency_ms": 8.171, + "transactions": 4896, + "wal_bytes_per_insert": 7550 } ] }, "chat_created_id": { - "bulk_insert_ms_per_1000": 11.79, - "bulk_fk_ms_per_1000": 31.32, - "bulk_total_ms_per_1000": 43.23, - "bulk_wal_bytes_per_row": 3036, - "tps_median": 3505.2, - "tps_min": 2773.7, - "tps_max": 3540.0, - "latency_ms_median": 1.141, + "bulk_insert_ms_per_1000": 10.71, + "bulk_fk_ms_per_1000": 19.87, + "bulk_total_ms_per_1000": 31.03, + "bulk_wal_bytes_per_row": 3035, + "tps_median": 3376.1, + "tps_min": 2738.2, + "tps_max": 3602.6, + "latency_ms_median": 1.185, "bulks": [ { - "insert_ms_per_1000": 12.47, - "fk_ms_per_1000": 32.83, - "total_ms_per_1000": 45.41, - "wal_bytes_per_row": 3060 + "insert_ms_per_1000": 10.68, + "fk_ms_per_1000": 19.73, + "total_ms_per_1000": 30.5, + "wal_bytes_per_row": 3061 }, { - "insert_ms_per_1000": 11.61, - "fk_ms_per_1000": 31.36, - "total_ms_per_1000": 43.1, - "wal_bytes_per_row": 3036 + "insert_ms_per_1000": 10.71, + "fk_ms_per_1000": 21.26, + "total_ms_per_1000": 32.07, + "wal_bytes_per_row": 3035 }, { - "insert_ms_per_1000": 11.07, - "fk_ms_per_1000": 29.45, - "total_ms_per_1000": 40.65, - "wal_bytes_per_row": 3036 + "insert_ms_per_1000": 11.04, + "fk_ms_per_1000": 22.12, + "total_ms_per_1000": 33.26, + "wal_bytes_per_row": 3035 }, { - "insert_ms_per_1000": 13.25, - "fk_ms_per_1000": 30.65, - "total_ms_per_1000": 44.01, - "wal_bytes_per_row": 3036 + "insert_ms_per_1000": 11.06, + "fk_ms_per_1000": 19.87, + "total_ms_per_1000": 31.03, + "wal_bytes_per_row": 3035 }, { - "insert_ms_per_1000": 11.79, - "fk_ms_per_1000": 31.32, - "total_ms_per_1000": 43.23, - "wal_bytes_per_row": 3036 + "insert_ms_per_1000": 10.3, + "fk_ms_per_1000": 19.29, + "total_ms_per_1000": 29.67, + "wal_bytes_per_row": 3035 } ], "attempts": [ { - "tps": 3531.073941, - "latency_ms": 1.133, - "transactions": 35297, - "wal_bytes_per_insert": 1976 + "tps": 3602.626694, + "latency_ms": 1.11, + "transactions": 36014, + "wal_bytes_per_insert": 1946 }, { - "tps": 3481.74199, - "latency_ms": 1.149, - "transactions": 34801, - "wal_bytes_per_insert": 1984 + "tps": 3376.107093, + "latency_ms": 1.185, + "transactions": 33751, + "wal_bytes_per_insert": 2032 }, { - "tps": 3540.023992, - "latency_ms": 1.13, - "transactions": 35383, - "wal_bytes_per_insert": 1959 + "tps": 3128.651853, + "latency_ms": 1.279, + "transactions": 31276, + "wal_bytes_per_insert": 2155 }, { - "tps": 3505.193506, - "latency_ms": 1.141, - "transactions": 35033, - "wal_bytes_per_insert": 1970 + "tps": 3399.102462, + "latency_ms": 1.177, + "transactions": 33982, + "wal_bytes_per_insert": 2019 }, { - "tps": 2773.668269, - "latency_ms": 1.442, - "transactions": 27725, - "wal_bytes_per_insert": 2375 + "tps": 2738.175055, + "latency_ms": 1.461, + "transactions": 27367, + "wal_bytes_per_insert": 2400 } ] }, "chat_created_id_plus_time": { - "bulk_insert_ms_per_1000": 12.78, - "bulk_fk_ms_per_1000": 30.83, - "bulk_total_ms_per_1000": 44.16, - "bulk_wal_bytes_per_row": 3121, - "tps_median": 3552.6, - "tps_min": 783.2, - "tps_max": 3578.8, - "latency_ms_median": 1.126, + "bulk_insert_ms_per_1000": 11.44, + "bulk_fk_ms_per_1000": 20.48, + "bulk_total_ms_per_1000": 32.02, + "bulk_wal_bytes_per_row": 3120, + "tps_median": 3566.2, + "tps_min": 2642.9, + "tps_max": 3650.8, + "latency_ms_median": 1.122, "bulks": [ { - "insert_ms_per_1000": 13.27, - "fk_ms_per_1000": 30.77, - "total_ms_per_1000": 44.16, + "insert_ms_per_1000": 12.02, + "fk_ms_per_1000": 19.57, + "total_ms_per_1000": 31.68, "wal_bytes_per_row": 3145 }, { - "insert_ms_per_1000": 12.78, - "fk_ms_per_1000": 31.66, - "total_ms_per_1000": 44.55, + "insert_ms_per_1000": 11.95, + "fk_ms_per_1000": 22.66, + "total_ms_per_1000": 34.71, "wal_bytes_per_row": 3120 }, { - "insert_ms_per_1000": 13.64, - "fk_ms_per_1000": 30.82, - "total_ms_per_1000": 44.57, - "wal_bytes_per_row": 3121 + "insert_ms_per_1000": 11.32, + "fk_ms_per_1000": 22.18, + "total_ms_per_1000": 33.59, + "wal_bytes_per_row": 3120 }, { - "insert_ms_per_1000": 12.73, - "fk_ms_per_1000": 30.83, - "total_ms_per_1000": 43.68, - "wal_bytes_per_row": 3121 + "insert_ms_per_1000": 11.44, + "fk_ms_per_1000": 20.48, + "total_ms_per_1000": 32.02, + "wal_bytes_per_row": 3120 }, { - "insert_ms_per_1000": 11.77, - "fk_ms_per_1000": 31.53, - "total_ms_per_1000": 43.43, - "wal_bytes_per_row": 3121 + "insert_ms_per_1000": 11.1, + "fk_ms_per_1000": 19.77, + "total_ms_per_1000": 30.95, + "wal_bytes_per_row": 3120 } ], "attempts": [ { - "tps": 3554.292554, - "latency_ms": 1.125, - "transactions": 35526, - "wal_bytes_per_insert": 2052 + "tps": 3546.172367, + "latency_ms": 1.128, + "transactions": 35449, + "wal_bytes_per_insert": 2054 }, { - "tps": 3552.622838, - "latency_ms": 1.126, - "transactions": 35510, - "wal_bytes_per_insert": 2039 + "tps": 3566.208524, + "latency_ms": 1.122, + "transactions": 35652, + "wal_bytes_per_insert": 2032 }, { - "tps": 3578.846119, - "latency_ms": 1.118, - "transactions": 35771, - "wal_bytes_per_insert": 2025 + "tps": 2642.919736, + "latency_ms": 1.513, + "transactions": 26420, + "wal_bytes_per_insert": 2556 }, { - "tps": 3376.236061, - "latency_ms": 1.185, - "transactions": 33745, - "wal_bytes_per_insert": 2115 + "tps": 3623.258363, + "latency_ms": 1.104, + "transactions": 36217, + "wal_bytes_per_insert": 2006 }, { - "tps": 783.210401, - "latency_ms": 5.107, - "transactions": 7833, - "wal_bytes_per_insert": 7365 + "tps": 3650.774819, + "latency_ms": 1.096, + "transactions": 36496, + "wal_bytes_per_insert": 1996 } ] } diff --git a/migrations/0002_unicode_text.sql b/migrations/0002_unicode_text.sql new file mode 100644 index 00000000..bf25a000 --- /dev/null +++ b/migrations/0002_unicode_text.sql @@ -0,0 +1,14 @@ +ALTER TABLE users + DROP CONSTRAINT users_display_name_check, + ALTER COLUMN display_name TYPE bytea USING convert_to(display_name, 'UTF8'), + ADD CONSTRAINT users_display_name_check CHECK (octet_length(display_name) BETWEEN 1 AND 400); + +ALTER TABLE chats + DROP CONSTRAINT chats_title_check, + ALTER COLUMN title TYPE bytea USING convert_to(title, 'UTF8'), + ADD CONSTRAINT chats_title_check CHECK (octet_length(title) BETWEEN 1 AND 400); + +ALTER TABLE messages + DROP CONSTRAINT messages_text_check, + ALTER COLUMN text TYPE bytea USING convert_to(text, 'UTF8'), + ADD CONSTRAINT messages_text_check CHECK (octet_length(text) BETWEEN 1 AND 16000); diff --git a/migrations/0003_session_revocations.sql b/migrations/0003_session_revocations.sql new file mode 100644 index 00000000..c2bcb84c --- /dev/null +++ b/migrations/0003_session_revocations.sql @@ -0,0 +1,6 @@ +CREATE TABLE session_revocations ( + token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32), + expires_at timestamptz NOT NULL +); + +CREATE INDEX session_revocations_expires_idx ON session_revocations (expires_at); diff --git a/research/seed.sql b/research/seed.sql index e0af74f0..dd42b229 100644 --- a/research/seed.sql +++ b/research/seed.sql @@ -1,7 +1,7 @@ SELECT setseed(0.42); INSERT INTO users (username, display_name, password_hash, created_at) -SELECT 'bench_' || lpad(g::text, 4, '0'), 'Bench ' || g, 'synthetic-no-login', timestamptz '2026-08-01 00:00:00Z' +SELECT 'bench_' || lpad(g::text, 4, '0'), convert_to('Bench ' || g, 'UTF8'), 'synthetic-no-login', timestamptz '2026-08-01 00:00:00Z' FROM generate_series(0, 999) AS g; CREATE TABLE bench_users AS @@ -15,7 +15,7 @@ FROM (VALUES ('big', 1, 100000, 200), ('medium', 20, 3000, 20), ('small', 4000, CROSS JOIN LATERAL generate_series(1, p.chats); INSERT INTO chats (id, title, created_by, created_at) -SELECT c.id, c.kind || ' ' || c.rn, u.id, timestamptz '2026-08-31 00:00:00Z' +SELECT c.id, convert_to(c.kind || ' ' || c.rn, 'UTF8'), u.id, timestamptz '2026-08-31 00:00:00Z' FROM bench_chats c JOIN bench_users u ON u.n = (c.rn * 37) % 1000; INSERT INTO chat_members (chat_id, user_id, position) @@ -25,7 +25,7 @@ CROSS JOIN LATERAL generate_series(0, c.members - 1) AS k JOIN bench_users u ON u.n = (c.rn * 37 + k) % 1000; INSERT INTO messages (chat_id, sender_id, text, created_at) -SELECT m.chat_id, u.id, left(repeat('Синтетическое сообщение ', 20), m.len), m.ts +SELECT m.chat_id, u.id, convert_to(left(repeat('Синтетическое сообщение ', 20), m.len), 'UTF8'), m.ts FROM ( SELECT c.id AS chat_id, c.rn, (random() * (c.members - 1))::int AS k, diff --git a/research/track2.py b/research/track2.py index 6d56ed9b..52a76f5f 100644 --- a/research/track2.py +++ b/research/track2.py @@ -12,6 +12,7 @@ import base64 from datetime import datetime, timezone import json +import os from pathlib import Path import re import statistics @@ -26,6 +27,7 @@ ROOT = Path(__file__).resolve().parents[1] OUT = ROOT / 'evidence' / 'track2' WARMUP, RUNS = 3, 15 PROJECT_VOLUME = 'grigoriev-lab2_pgdata_restore' +RESTORE_PORT = int(os.environ.get('RESTORE_API_PORT', '8081')) VARIANTS = { 'pk_only': [], @@ -323,8 +325,8 @@ def restore(): in_restored = int(psql("SELECT count(*) FROM messages WHERE text = 'during dump'", service='postgres-restore')) times['api_restore_ready'] = timed(lambda: compose('up', '-d', '--wait', '--no-build', 'api-restore')) - status_me = api('GET', '/api/v1/users/me', 8081, token)[0] - page = api('GET', '/api/v1/chats/%s/messages' % chat['id'], 8081, token)[1] + status_me = api('GET', '/api/v1/users/me', RESTORE_PORT, token)[0] + page = api('GET', '/api/v1/chats/%s/messages' % chat['id'], RESTORE_PORT, token)[1] api_ok = status_me == 200 and page['items'] == [message] mismatches = [k for k in CHECKSUMS if source[k] != restored[k]] data = {'environment': environment(), 'dump_bytes': dump_bytes, 'times_seconds': times, diff --git a/src/app.py b/src/app.py index 99b2618c..5cad9ca4 100644 --- a/src/app.py +++ b/src/app.py @@ -12,7 +12,8 @@ from starlette.exceptions import HTTPException as StarletteHTTPException import auth from cache import cache -from db import pool +from config import settings +from db import connection, pool, request_deadline from errors import ApiError, error_response from models import CreateChat, CreateMessage, CreateUser import store @@ -45,6 +46,7 @@ app = FastAPI(title='MTUSI Messenger lab2', lifespan=lifespan) @app.middleware('http') async def request_context(request: Request, call_next): request.state.request_id = uuid.uuid4().hex + request_deadline.set(time.monotonic() + settings.db_request_timeout) started = time.perf_counter() try: response = await call_next(request) @@ -82,11 +84,6 @@ async def handle_validation_error(request: Request, exc: RequestValidationError) return error_response(request, 400, 'Некорректный запрос: ' + where) -@app.exception_handler(psycopg.DataError) -async def handle_data_error(request: Request, exc: psycopg.DataError): - return error_response(request, 400, 'Некорректные данные') - - @app.exception_handler(psycopg.OperationalError) @app.exception_handler(psycopg.InterfaceError) async def handle_database_unavailable(request: Request, exc: psycopg.Error): @@ -103,7 +100,7 @@ async def liveness(): def readiness(): if not state['ready']: raise ApiError(503, 'Сервис не готов') - with pool.connection(timeout=1) as conn: + with connection(limit=1) as conn: conn.execute('SELECT 1') return {'status': 'ok'} diff --git a/src/auth.py b/src/auth.py index 30beef93..9aafd2f6 100644 --- a/src/auth.py +++ b/src/auth.py @@ -6,6 +6,7 @@ import secrets from argon2 import PasswordHasher from argon2.exceptions import InvalidHashError, VerificationError +import psycopg from cache import REVOKED, cache from config import settings @@ -13,6 +14,8 @@ from db import iso from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, unauthorized import store +REVOCATION_MARGIN_SECONDS = 5 + USERNAME = re.compile(r'^[a-z0-9_]{3,32}$') hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) @@ -77,6 +80,8 @@ def authenticate(header): if token is None or not token.isascii(): raise unauthorized(BEARER_CHALLENGE) digest = token_hash(token) + if cache.client is not None and not cache.synced: + sync_revocations() user = cache.get(digest) if user == REVOKED: raise unauthorized(BEARER_CHALLENGE) @@ -89,6 +94,26 @@ def authenticate(header): return {'user': user, 'token_hash': digest} +def sync_revocations(): + errors_before = cache.errors + try: + pending = store.pending_revocations() + except psycopg.Error: + return + if not cache.revoke_all(pending): + return + if pending: + try: + store.clear_revocations(pending) + except psycopg.Error: + pass + cache.mark_synced(errors_before) + + def logout(session): - store.delete_session(session['token_hash']) - cache.revoke(session['token_hash']) + store.revoke_session(session['token_hash'], cache.max_ttl + REVOCATION_MARGIN_SECONDS) + if cache.revoke(session['token_hash']): + try: + store.clear_revocations([session['token_hash']]) + except psycopg.Error: + pass diff --git a/src/cache.py b/src/cache.py index e3fe2223..c44eb033 100644 --- a/src/cache.py +++ b/src/cache.py @@ -1,6 +1,7 @@ from datetime import datetime, timezone import json import logging +import threading import time import redis @@ -20,7 +21,9 @@ class SessionCache: decode_responses=True) if url else None self.max_ttl = max_ttl self.bypass_until = 0.0 - self.pending = set() + self.lock = threading.Lock() + self.errors = 0 + self.synced = False def _run(self, action, force=False): if self.client is None: @@ -32,25 +35,23 @@ class SessionCache: except redis.RedisError as error: log.warning('session cache unavailable (%s), using PostgreSQL for %ds', type(error).__name__, BYPASS_SECONDS) self.bypass_until = time.monotonic() + BYPASS_SECONDS + with self.lock: + self.errors += 1 + self.synced = False return FAILED @staticmethod def key(token_hash): return 'session:' + token_hash.hex() - def _tombstone(self, token_hash, force=False): - return self._run(lambda c: c.set(self.key(token_hash), REVOKED, ex=self.max_ttl), force) is not FAILED - - def _apply_pending(self): - for token_hash in list(self.pending): - if not self._tombstone(token_hash): - return False - self.pending.discard(token_hash) - return True + def mark_synced(self, errors_before): + with self.lock: + if self.errors == errors_before: + self.synced = True def get(self, token_hash): - if self.pending and not self._apply_pending(): - return REVOKED if token_hash in self.pending else None + if not self.synced: + return None raw = self._run(lambda c: c.get(self.key(token_hash))) if raw is FAILED or not raw or raw == REVOKED: return REVOKED if raw == REVOKED else None @@ -68,8 +69,16 @@ class SessionCache: self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl, nx=True)) def revoke(self, token_hash): - if self.client is not None and not self._tombstone(token_hash, force=True): - self.pending.add(token_hash) + return self._run(lambda c: c.set(self.key(token_hash), REVOKED, ex=self.max_ttl), force=True) is not FAILED + + def revoke_all(self, token_hashes): + def write(client): + with client.pipeline(transaction=False) as pipe: + for token_hash in token_hashes: + pipe.set(self.key(token_hash), REVOKED, ex=self.max_ttl) + pipe.execute() + return True + return not token_hashes or self._run(write) is not FAILED cache = SessionCache(settings.cache_url, settings.session_cache_ttl) diff --git a/src/config.py b/src/config.py index f1308c10..470040ee 100644 --- a/src/config.py +++ b/src/config.py @@ -29,7 +29,8 @@ class Settings: self.db_pool_min = positive_int('DB_POOL_MIN', '1') self.db_pool_max = positive_int('DB_POOL_MAX', '10') self.db_pool_timeout = float(os.environ.get('DB_POOL_TIMEOUT_SECONDS', '2')) - self.db_statement_timeout_ms = positive_int('DB_STATEMENT_TIMEOUT_MS', '5000') + self.db_statement_timeout_ms = positive_int('DB_STATEMENT_TIMEOUT_MS', '3000') + self.db_request_timeout = float(os.environ.get('DB_REQUEST_TIMEOUT_SECONDS', '4')) if not self.database_url: raise SystemExit('DATABASE_URL or DATABASE_URL_FILE is required') diff --git a/src/db.py b/src/db.py index c1dc8790..6eb1af01 100644 --- a/src/db.py +++ b/src/db.py @@ -1,16 +1,85 @@ +from contextlib import contextmanager +import contextvars from datetime import timezone +import itertools +import logging +import os +import socket +import threading +import time +import psycopg from psycopg.rows import dict_row from psycopg_pool import ConnectionPool from config import settings +log = logging.getLogger('messenger.db') + +request_deadline = contextvars.ContextVar('request_deadline', default=None) + +CHECK_SECONDS = 1 + + +def abort(conn): + try: + sock = socket.socket(fileno=os.dup(conn.fileno())) + except (OSError, psycopg.Error): + return + try: + sock.shutdown(socket.SHUT_RDWR) + except OSError: + pass + finally: + sock.close() + + +class Watchdog: + def __init__(self): + self.cond = threading.Condition() + self.armed = {} + self.ids = itertools.count() + threading.Thread(target=self.loop, name='db-watchdog', daemon=True).start() + + @contextmanager + def guard(self, conn, seconds): + key = next(self.ids) + with self.cond: + self.armed[key] = (time.monotonic() + seconds, conn) + self.cond.notify() + try: + yield + finally: + with self.cond: + self.armed.pop(key, None) + + def loop(self): + with self.cond: + while True: + now = time.monotonic() + for key, (deadline, conn) in list(self.armed.items()): + if deadline <= now: + del self.armed[key] + log.warning('database did not answer in time, aborting connection') + abort(conn) + wake = min((deadline for deadline, _ in self.armed.values()), default=now + 60) + self.cond.wait(max(wake - now, 0.01)) + + +watchdog = Watchdog() + + +def check(conn): + with watchdog.guard(conn, CHECK_SECONDS): + ConnectionPool.check_connection(conn) + + pool = ConnectionPool( settings.database_url, min_size=settings.db_pool_min, max_size=settings.db_pool_max, timeout=settings.db_pool_timeout, - check=ConnectionPool.check_connection, + check=check, open=False, name='messenger', kwargs={ @@ -21,5 +90,33 @@ pool = ConnectionPool( ) +def remaining(limit=None): + deadline = request_deadline.get() + left = settings.db_request_timeout if deadline is None else deadline - time.monotonic() + if limit is not None: + left = min(left, limit) + if left <= 0: + raise psycopg.OperationalError('request deadline exceeded') + return left + + +@contextmanager +def connection(limit=None): + conn = pool.getconn(timeout=min(settings.db_pool_timeout, remaining(limit))) + try: + with watchdog.guard(conn, remaining(limit)): + try: + yield conn + except BaseException: + try: + conn.rollback() + except psycopg.Error: + pass + raise + conn.commit() + finally: + pool.putconn(conn) + + def iso(value): return value.astimezone(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ') diff --git a/src/models.py b/src/models.py index 31387bf4..a1dab270 100644 --- a/src/models.py +++ b/src/models.py @@ -8,6 +8,10 @@ class StrictModel(BaseModel): def not_blank(value): if not value.strip(): raise ValueError('must not be blank') + try: + value.encode('utf-8') + except UnicodeEncodeError: + raise ValueError('must be valid Unicode') from None return value diff --git a/src/store.py b/src/store.py index 2203d583..cbf33720 100644 --- a/src/store.py +++ b/src/store.py @@ -2,7 +2,7 @@ import uuid from psycopg import errors -from db import iso, pool +from db import connection, iso from errors import ApiError from pagination import decode_cursor, page @@ -13,41 +13,49 @@ CHAT_SELECT = ('SELECT c.id, c.title, c.created_at, ' 'FROM chats c ') +def utf8(value): + return value.encode('utf-8') + + +def unicode(value): + return bytes(value).decode('utf-8') + + def user_out(row): return {'id': str(row['id']), 'username': row['username'], - 'display_name': row['display_name'], 'created_at': iso(row['created_at'])} + 'display_name': unicode(row['display_name']), 'created_at': iso(row['created_at'])} def chat_out(row): - return {'id': str(row['id']), 'title': row['title'], + return {'id': str(row['id']), 'title': unicode(row['title']), 'member_ids': [str(m) for m in row['member_ids']], 'created_at': iso(row['created_at'])} def message_out(row): return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'sender_id': str(row['sender_id']), - 'text': row['text'], 'created_at': iso(row['created_at'])} + 'text': unicode(row['text']), 'created_at': iso(row['created_at'])} def create_user(username, display_name, password_hash): try: - with pool.connection() as conn: + with connection() as conn: row = conn.execute( 'INSERT INTO users AS u (username, display_name, password_hash) VALUES (%s, %s, %s) ' 'RETURNING ' + USER_COLUMNS, - (username, display_name, password_hash)).fetchone() + (username, utf8(display_name), password_hash)).fetchone() except errors.UniqueViolation: raise ApiError(409, 'Имя пользователя уже занято') from None return user_out(row) def find_credentials(username): - with pool.connection() as conn: + with connection() as conn: return conn.execute('SELECT ' + USER_COLUMNS + ', u.password_hash FROM users u WHERE u.username = %s', (username,)).fetchone() def create_session(user_id, token_hash, ttl_seconds): - with pool.connection() as conn: + with connection() as conn: conn.execute('DELETE FROM sessions WHERE user_id = %s AND expires_at <= now()', (user_id,)) return conn.execute( 'INSERT INTO sessions (token_hash, user_id, expires_at) ' @@ -56,16 +64,31 @@ def create_session(user_id, token_hash, ttl_seconds): def session_user(token_hash): - with pool.connection() as conn: + with connection() as conn: return conn.execute( 'SELECT ' + USER_COLUMNS + ', s.expires_at FROM sessions s JOIN users u ON u.id = s.user_id ' 'WHERE s.token_hash = %s AND s.expires_at > now()', (token_hash,)).fetchone() -def delete_session(token_hash): - with pool.connection() as conn: +def revoke_session(token_hash, keep_seconds): + with connection() as conn: conn.execute('DELETE FROM sessions WHERE token_hash = %s', (token_hash,)) + conn.execute('INSERT INTO session_revocations (token_hash, expires_at) ' + 'VALUES (%s, now() + make_interval(secs => %s)) ' + 'ON CONFLICT (token_hash) DO UPDATE SET expires_at = EXCLUDED.expires_at', + (token_hash, keep_seconds)) + + +def pending_revocations(): + with connection() as conn: + conn.execute('DELETE FROM session_revocations WHERE expires_at <= now()') + return [bytes(r['token_hash']) for r in conn.execute('SELECT token_hash FROM session_revocations').fetchall()] + + +def clear_revocations(token_hashes): + with connection() as conn: + conn.execute('DELETE FROM session_revocations WHERE token_hash = ANY(%s)', (list(token_hashes),)) def create_chat(creator_id, title, member_ids): @@ -78,9 +101,9 @@ def create_chat(creator_id, title, member_ids): if creator_id not in members: raise ApiError(400, 'Создатель должен быть участником чата') try: - with pool.connection() as conn, conn.transaction(): + with connection() as conn, conn.transaction(): chat = conn.execute('INSERT INTO chats (title, created_by) VALUES (%s, %s) RETURNING id, title, created_at', - (title, creator_id)).fetchone() + (utf8(title), creator_id)).fetchone() conn.execute('INSERT INTO chat_members (chat_id, user_id, position) ' 'SELECT %s, member, position FROM unnest(%s::uuid[]) WITH ORDINALITY AS t(member, position)', (chat['id'], members)) @@ -90,7 +113,7 @@ def create_chat(creator_id, title, member_ids): def get_chat(chat_id, user_id): - with pool.connection() as conn: + with connection() as conn: row = conn.execute(CHAT_SELECT + 'JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s ' 'WHERE c.id = %s', (user_id, chat_id)).fetchone() if row is None: @@ -106,7 +129,7 @@ def list_chats(user_id, cursor, limit): sql += 'AND (c.created_at, c.id) > (%s, %s) ' params += decode_cursor(scope, cursor) sql += 'ORDER BY c.created_at, c.id LIMIT %s' - with pool.connection() as conn: + with connection() as conn: rows = conn.execute(sql, params + [limit + 1]).fetchall() return page([chat_out(r) for r in rows], scope, limit) @@ -117,12 +140,12 @@ def is_member(conn, chat_id, user_id): def create_message(chat_id, sender_id, text): - with pool.connection() as conn: + with connection() as conn: row = conn.execute( 'INSERT INTO messages (chat_id, sender_id, text) SELECT %s, %s, %s ' 'WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s) ' 'RETURNING ' + MESSAGE_COLUMNS, - (chat_id, sender_id, text, chat_id, sender_id)).fetchone() + (chat_id, sender_id, utf8(text), chat_id, sender_id)).fetchone() if row is None: raise ApiError(404, 'Чат не найден') return message_out(row) @@ -136,7 +159,7 @@ def list_messages(chat_id, user_id, cursor, limit): sql += 'AND (created_at, id) > (%s, %s) ' params += decode_cursor(scope, cursor) sql += 'ORDER BY created_at, id LIMIT %s' - with pool.connection() as conn: + with connection() as conn: if not is_member(conn, chat_id, user_id): raise ApiError(404, 'Чат не найден') rows = conn.execute(sql, params + [limit + 1]).fetchall() diff --git a/student-tests/failure_check.py b/student-tests/failure_check.py index 11569415..a6ffa7ce 100644 --- a/student-tests/failure_check.py +++ b/student-tests/failure_check.py @@ -1,8 +1,8 @@ """Usage (стенд уже запущен через docker compose up -d): python student-tests/failure_check.py -Останавливает Valkey, затем PostgreSQL (docker compose stop, без удаления volumes), -проверяет поведение API и восстановление после docker compose start. +Останавливает и замораживает Valkey и PostgreSQL (docker compose stop/pause, без удаления volumes), +проверяет поведение API и восстановление. """ import time import uuid @@ -65,6 +65,20 @@ def main(): expect('через 6 с после unpause: /users/me', timed('GET', '/api/v1/users/me', revoked['token']), [401], 1) expect('через 6 с после unpause: сообщение', timed('POST', history, revoked['token'], {'text': 'после logout'}), [401], 1) + print('1в. Valkey на паузе: logout, рестарт API, unpause — отзыв переживает рестарт процесса') + restarted = new_user('restart') + call('GET', '/api/v1/users/me', token=restarted['token']) + compose('pause', 'valkey') + try: + expect('logout при паузе Valkey', timed('DELETE', '/api/v1/auth/sessions/current', restarted['token']), [204], 1.5) + compose('restart', 'api') + wait_ready() + finally: + compose('unpause', 'valkey') + time.sleep(6) + expect('после рестарта API и unpause: /users/me', timed('GET', '/api/v1/users/me', restarted['token']), [401], 1) + expect('после рестарта API и unpause: сообщение', timed('POST', history, restarted['token'], {'text': 'после рестарта'}), [401], 1) + print('2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит') compose('stop', 'postgres') stopped_at = time.monotonic() @@ -87,6 +101,24 @@ def main(): if status != 200 or texts != ['до отказа', 'без кэша']: failures.append('восстановление') + print('4. PostgreSQL заморожен (pause): запросы получают 503 в пределах общего срока, а не зависают') + compose('pause', 'postgres') + try: + expect('GET история', timed('GET', history, alice['token']), [503], 4.5) + expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'при заморозке'}), [503], 4.5) + expect('неизвестный токен (не 200!)', timed('GET', '/api/v1/users/me', fake), [503], 4.5) + expect('вход по Basic', timed('POST', '/api/v1/auth/sessions', headers=basic(alice['username'], alice['password'])), [503], 4.5) + expect('/health/ready', timed('GET', '/health/ready'), [503], 2) + expect('/health/live', timed('GET', '/health/live'), [200], 1) + finally: + compose('unpause', 'postgres') + unpaused = time.monotonic() + wait_ready() + texts = [m['text'] for m in call('GET', history + '?limit=100', token=alice['token'])[2]['items']] + print(' готовность через %.1f с после unpause; история: %s' % (time.monotonic() - unpaused, texts)) + if texts != ['до отказа', 'без кэша']: + failures.append('после заморозки') + print('FAIL: ' + ', '.join(failures) if failures else 'PASS: отказы Valkey и PostgreSQL обработаны') raise SystemExit(1 if failures else 0) diff --git a/student-tests/test_api.py b/student-tests/test_api.py index 502fbd65..be589b60 100644 --- a/student-tests/test_api.py +++ b/student-tests/test_api.py @@ -1,7 +1,7 @@ import unittest import uuid -from helpers import call, new_chat, new_user, read_all_messages +from helpers import call, login, new_chat, new_user, read_all_messages class ErrorFormatMixin: @@ -130,12 +130,27 @@ class IdentityTest(ErrorFormatMixin, unittest.TestCase): forged = call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': 'hi', 'sender_id': bob['id']}, alice['token']) self.assertError(forged, 400, 'invalid_request') - def test_nul_character_is_rejected(self): - """Символ NUL нельзя сохранить в PostgreSQL text -> 400, а не 500""" + def test_nul_character_is_preserved(self): + """U+0000 — допустимый code point: сообщение, display_name и title сохраняются и читаются без изменений""" + username, password = 'nul_' + uuid.uuid4().hex[:12], 'Nul-password-123' + status, _, user = call('POST', '/api/v1/users', {'username': username, 'display_name': 'a\u0000lice', 'password': password}) + self.assertEqual((status, user['display_name']), (201, 'a\u0000lice')) + alice = dict(user, token=login(username, password)['token']) + self.assertEqual(call('GET', '/api/v1/users/me', token=alice['token'])[2]['display_name'], 'a\u0000lice') + status, _, chat = call('POST', '/api/v1/chats', {'title': 't\u0000', 'member_ids': [alice['id']]}, alice['token']) + self.assertEqual((status, chat['title']), (201, 't\u0000')) + path = '/api/v1/chats/%s/messages' % chat['id'] + status, _, message = call('POST', path, {'text': 'a\u0000b'}, alice['token']) + self.assertEqual((status, message['text']), (201, 'a\u0000b')) + self.assertEqual(call('GET', path, token=alice['token'])[2]['items'][0]['text'], 'a\u0000b') + self.assertEqual(call('GET', '/api/v1/chats/' + chat['id'], token=alice['token'])[2]['title'], 't\u0000') + + def test_lone_surrogate_is_rejected(self): + """Одиночный суррогат не кодируется в UTF-8 -> 400, а не 500""" alice = new_user('alice') chat = new_chat(alice) - self.assertError(call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': 'a\u0000b'}, alice['token']), - 400, 'invalid_request') + self.assertError(call('POST', '/api/v1/chats/%s/messages' % chat['id'], raw=b'{"text": "a\\ud800b"}', + token=alice['token']), 400, 'invalid_request') if __name__ == '__main__': -- 2.54.0