ЛР 3 — БПИ2304 — Яковлев — на 3 #163

Closed
tankist wants to merge 2 commits from tankist/mtusi2026lab3:solution/BPI2304-Yakovlev into main
18 changed files with 1204 additions and 21 deletions
+14 -6
View File
@@ -1,13 +1,21 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Values below are placeholders, not secrets. Choose your own local values.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# Shared PostgreSQL for BOTH API replicas
POSTGRES_USER=messenger
POSTGRES_PASSWORD=replace-with-local-synthetic-password
POSTGRES_DB=messenger
DATABASE_URL=postgresql://messenger:replace-with-local-synthetic-password@db:5432/messenger
# Alternative for deployments that mount a secret file instead of an env variable:
# DATABASE_URL_FILE=/run/secrets/database_url
# Lab3 topology
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
# Redis/Valkey is not used on level 3; sessions and the idempotency ledger are in PostgreSQL.
# SESSION_STORE=postgres
+16
View File
@@ -0,0 +1,16 @@
FROM python:3.12-slim
ENV PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1 PIP_NO_CACHE_DIR=1
WORKDIR /opt/app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY app/ ./app/
COPY migrations/ ./migrations/
RUN useradd --create-home --uid 10001 appuser && chown -R appuser:appuser /opt/app
USER appuser
EXPOSE 8080
CMD ["python", "-m", "app"]
+71 -15
View File
@@ -1,37 +1,93 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Яковлев Матвей Дмитриевич, БПИ2304
- Целевая оценка; выбранный трек 5, если нужен: 3
- Commit/PR: ветка: (solution/BPI2304-Yakovlev); MR: (https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/163)
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI 0.135.3, Uvicorn 0.44.0, psycopg 3.3.3, PostgreSQL 16-alpine, nginx 1.27-alpine; версии закреплены в `requirements.txt`, `compose.yaml`, `Dockerfile`. При подготовке использовалась помощь Claude.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
```sh
git clone <url-вашего-fork> && cd <каталог>
cp .env.example .env # только синтетические локальные креды; .env в Git не попадает
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
curl -i http://localhost:8080/health/ready # единая точка входа — nginx
python tests/smoke.py --base-url http://localhost:8080
```
Единственный публичный порт — 8080 балансировщика; напрямую API-реплики портов не публикуют.
Остановка с сохранением данных: `docker compose --env-file .env stop api1 api2 db`.
Намеренное удаление учебных данных: `docker compose --env-file .env down -v`.
Явные сценарии проверок:
```sh
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
# Windows локально: scripts/restart.cmd и scripts/stop-one.cmd
```
После останова одной реплики восстановление — отдельной командой:
`docker compose --env-file .env start api1` (или `api2`).
Полный вывод — `evidence/lifecycle.txt`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → **nginx** (`lb`) → **api1 / api2** (один образ, две interchangeables реплики) → общий **PostgreSQL**.
- `infra/nginx.conf`: upstream с `api1:8080` и `api2:8080`, `max_fails=1 fail_timeout=5s`,
`proxy_next_upstream error timeout http_502 http_503 http_504`, таймауты 2/10/10 с.
Sticky session не используется: любая реплика обслуживает любой запрос с тем же Bearer-токеном.
- `X-Instance-Id`: каждой реплике через окружение задаётся alias `api1`/`api2`; заголовок
добавляется middleware в каждый ответ. Один клиент видит оба значения через LB (см. доказательства).
- Общее состояние: PostgreSQL хранит пользователей, чаты, участников, сообщения, сессии —
в памяти процесса нет authoritative данных. Сессии не требуют повторного входа при смене реплики.
- Миграции: `SELECT pg_advisory_xact_lock(20261116)` перед чтением `schema_migrations`, поэтому
при одновременном старте двух реплик файл `001_init.sql` применяется ровно один раз.
- **Общая идемпотентность**: таблица `idempotency_records` с первичным ключом
`(user_id, method, path, key)` в той же БД. `POST /chats/{id}/messages` требует
`Idempotency-Key` (`[A-Za-z0-9._:-]{1,128}`); хэш канонического тела, код и тело ответа
записываются **в одной транзакции** с сообщением. Повтор с тем же ключом возвращает
сохранённый `201` и тот же Message; другое тело с тем же ключом — `409`. При конкуренции
двух реплик проигравший ловит `UniqueViolation`, откатывается и читает зафиксированный
ответ победителя — дубля нет. Повтор снова проверяет сессию и доступ к чату.
- `scripts/stop-one.sh` отображает `TARGET_INSTANCE_ID` (alias из `X-Instance-Id`) на
соответствующий Compose-сервис и останавливает только его; БД, volume и LB не трогаются.
`scripts/restart.sh` перезапускает `db`, `api1`, `api2` без удаления volume.
- `/health/ready` проверяет `SELECT 1`; nginx не использует пассивные проверки API как
единственный механизм — при отказе реплики запрос повторяется на другой.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| ≥2 реплики, одна точка входа | `docker compose ps`; 8 запросов к LB | `api1`/`api2` в заголовке `X-Instance-Id` у одного клиента; только `lb` публикует 8080 | `evidence/lifecycle.txt`, разделы 2–3 |
| Публичный smoke c идемпотентностью | `python tests/smoke.py` | `PASS: lab3 public API scenario...`; повтор ключа = тот же Message, другой body = 409 | `evidence/lifecycle.txt`, раздел 4 |
| Общая идемпотентность в БД | `psql ... SELECT count(*) FROM idempotency_records` | число записей ledger равно числу сообщений; уникальный ключ `(user, method, path, key)` | `evidence/lifecycle.txt`, раздел 5 |
| Перезапуск всего стенда с тем же токеном | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session`; `schema_migrations` без повторов (advisory lock) | `evidence/lifecycle.txt`, разделы 6–7 |
| Отказ одной реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | `observed_instances_before: 2`, 106 успешных записей, 2 transitional failure, `first_recovery_seconds: 0.608`, PASS | `evidence/lifecycle.txt`, разделы 8–9 |
| Офлайн-проверки | `python scripts/check_contract.py`; 11 unit-тестов | PASS, 11 OK | `evidence/lifecycle.txt`, раздел 10 |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Не проводились (целевая оценка 3); уровни 4/5 с нагрузочными сериями и сравнением
1/2/4 реплик не заявлены.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Останов одной API-реплики hook'ом | LB направляет запросы на оставшуюся реплику; данные и сессия сохраняются | 2 реплики до отказа, 106 успешных записей во время отказа, 2 переходные ошибки, все подтверждённые сообщения на месте, дублей нет | первая успешная запись через 0.608 с; потерь данных 0 |
| Перезапуск `db` + `api1` + `api2` с volume | данные, сессии и ledger остаются | PASS; миграции не применялись повторно | automatic ready wait; потерь данных 0 |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Уровень 4 не реализован: нет CPU/RAM-лимитов, sequnential отказа каждой реплики под
нагрузкой, rolling update и автоматической проверки исключения недоступного backend
по healthcheck (nginx использует пассивный `max_fails`/`fail_timeout`).
- PostgreSQL остаётся единственной точкой отказа стенда; отказ узла БД не моделируется
и не заявляется.
- Nginx — единственный LB; при его отказе доступ прекращается (SPOF).
- HTTP допустим только для локального изолированного стенда с синтетическими данными;
для удалённой демонстрации нужен TLS.
+1
View File
@@ -0,0 +1 @@
"""Messenger lab2: PostgreSQL-backed API."""
+13
View File
@@ -0,0 +1,13 @@
"""Local entry point: python -m app"""
import os
import uvicorn
if __name__ == "__main__":
uvicorn.run(
"app.main:app",
host=os.environ.get("APP_HOST", "0.0.0.0"),
port=int(os.environ.get("APP_PORT", "8080")),
workers=1, # in-process ordering/cursors; PostgreSQL is the shared source of truth
log_level=os.environ.get("LOG_LEVEL", "info"),
)
+150
View File
@@ -0,0 +1,150 @@
"""PostgreSQL access: small bounded connection pool, versioned migrations, row helpers."""
import logging
import os
import queue
from contextlib import contextmanager
from datetime import timezone
from pathlib import Path
import psycopg
from psycopg.rows import dict_row
log = logging.getLogger("messenger.db")
ROOT = Path(__file__).resolve().parents[1]
MIGRATIONS = ROOT / "migrations"
def _read_secret(path):
if not path:
return None
value = Path(path).read_text(encoding="utf-8").strip()
if not value:
raise RuntimeError("secret file is empty: " + path)
return value
def database_url():
"""Prefer a mounted secret file; fall back to an environment variable for local runs."""
url = _read_secret(os.environ.get("DATABASE_URL_FILE"))
if url:
return url
url = os.environ.get("DATABASE_URL")
if not url:
raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required")
return url
class Database:
"""A tiny FIFO pool. Each request borrows one connection and returns it."""
def __init__(self):
self._pool = None
self.dsn = None
def start(self):
self.dsn = database_url()
size = int(os.environ.get("DB_POOL_MAX", "8"))
self._pool = queue.Queue(maxsize=size)
for _ in range(size):
self._pool.put(self._connect())
self.migrate()
def _connect(self):
return psycopg.connect(self.dsn, connect_timeout=3, row_factory=dict_row, autocommit=True)
def stop(self):
if self._pool is None:
return
while not self._pool.empty():
try:
self._pool.get_nowait().close()
except queue.Empty:
break
self._pool = None
@contextmanager
def connection(self):
conn = self._pool.get(timeout=5)
try:
yield conn
finally:
self._pool.put(conn)
@contextmanager
def transaction(self):
with self.connection() as conn:
# Explicit BEGIN/COMMIT; rollback on any exception.
conn.execute("BEGIN")
try:
yield conn
except BaseException:
conn.execute("ROLLBACK")
raise
else:
conn.execute("COMMIT")
def ready(self):
try:
with self.connection() as conn:
conn.execute("SELECT 1").fetchone()
return True
except Exception:
log.exception("readiness check failed")
return False
def migrate(self):
"""Apply *.sql in name order, at most once each; restart-safe with the same volume."""
with self.transaction() as conn:
# All API replicas start against the same database. A transaction-scoped
# advisory lock makes the migration step strictly single-runner:
# the second replica waits, then sees schema_migrations already filled.
conn.execute("SELECT pg_advisory_xact_lock(20261116)")
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
"name TEXT PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp())"
)
applied = {r["name"] for r in conn.execute("SELECT name FROM schema_migrations").fetchall()}
for path in sorted(MIGRATIONS.glob("*.sql")):
if path.name in applied:
continue
conn.execute(path.read_text(encoding="utf-8"))
conn.execute("INSERT INTO schema_migrations(name) VALUES (%s)", (path.name,))
log.info("applied migration %s", path.name)
db = Database()
def utc_text(value):
"""RFC 3339 UTC with an explicit Z and microsecond precision."""
value = value.astimezone(timezone.utc)
return value.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def user_public(row):
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": utc_text(row["created_at"]),
}
def chat_public(row):
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(x) for x in (row["member_ids"] or [])],
"created_at": utc_text(row["created_at"]),
}
def message_public(row):
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": utc_text(row["created_at"]),
}
+475
View File
@@ -0,0 +1,475 @@
"""Lab2 messenger HTTP layer. Contract: contracts/openapi.json.
State lives in PostgreSQL: users, chats, memberships, messages and sessions.
Basic is accepted only on POST /auth/sessions; every other protected route needs Bearer.
"""
import base64
import binascii
import datetime as dt
import hashlib
import json
import logging
import os
import re
import uuid
from contextlib import asynccontextmanager
import psycopg
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from starlette.datastructures import MutableHeaders
from starlette.exceptions import HTTPException as StarletteHTTPException
from .db import chat_public, db, message_public, user_public, utc_text
from .security import bearer_token, hash_password, parse_basic, token_hash, verify_password
log = logging.getLogger("messenger")
MAX_BODY_BYTES = 1 << 20
DEFAULT_LIMIT, MAX_LIMIT = 50, 100
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}\Z")
UUID_RE = re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\Z")
IDEMPOTENCY_KEY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}\Z")
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
INSTANCE_ID = os.environ.get("INSTANCE_ALIAS") or uuid.uuid4().hex[:12]
UTC = dt.timezone.utc
class ApiError(Exception):
def __init__(self, status, code, message, headers=None):
self.status, self.code, self.message, self.headers = status, code, message, headers
def bad_request(message):
return ApiError(400, "invalid_request", message)
def unauthorized(challenge, message="Требуется действительная аутентификация"):
return ApiError(401, "unauthorized", message, {"WWW-Authenticate": challenge})
def not_found():
return ApiError(404, "not_found", "Объект не найден")
def error_response(status, code, message, request_id, headers=None):
body = {"error": {"code": code, "message": message, "request_id": request_id}}
return JSONResponse(body, status_code=status, headers=headers)
class RequestContextMiddleware:
"""Add X-Request-Id (and X-Instance-Id) to every response, including errors and health."""
def __init__(self, app):
self.app = app
async def __call__(self, scope, receive, send):
if scope["type"] != "http":
await self.app(scope, receive, send)
return
request_id = str(uuid.uuid4())
scope.setdefault("state", {})["request_id"] = request_id
started = False
async def send_with_id(message):
nonlocal started
if message["type"] == "http.response.start":
started = True
headers = MutableHeaders(scope=message)
headers["X-Request-Id"] = request_id
headers["X-Instance-Id"] = INSTANCE_ID
await send(message)
try:
await self.app(scope, receive, send_with_id)
except Exception:
log.exception("unhandled error request_id=%s", request_id)
if not started:
response = error_response(500, "internal_error", "Внутренняя ошибка сервера", request_id)
await response(scope, receive, send_with_id)
@asynccontextmanager
async def lifespan(app):
db.start()
try:
yield
finally:
db.stop()
app = FastAPI(title="Messenger lab2", docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
app.add_middleware(RequestContextMiddleware)
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
return error_response(exc.status, exc.code, exc.message, request.state.request_id, exc.headers)
@app.exception_handler(StarletteHTTPException)
async def handle_http_exception(request: Request, exc: StarletteHTTPException):
if exc.status_code == 404:
code, message = "not_found", "Объект не найден"
elif exc.status_code < 500:
code, message = "invalid_request", "Некорректный запрос"
else:
code, message = "internal_error", "Внутренняя ошибка сервера"
return error_response(exc.status_code, code, message, request.state.request_id, exc.headers)
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError):
return error_response(400, "invalid_request", "Некорректный запрос", request.state.request_id)
# ---------- validation helpers ----------
def clean_string(data, field, max_len):
value = data.get(field)
if not isinstance(value, str):
raise bad_request("Поле %s должно быть строкой" % field)
if not value.strip() or len(value) > max_len:
raise bad_request("Поле %s должно содержать от 1 до %d символов" % (field, max_len))
return value
def idempotency_key(request):
value = request.headers.get("idempotency-key")
if not value or not IDEMPOTENCY_KEY_RE.fullmatch(value):
raise bad_request("Idempotency-Key обязателен и должен соответствовать [A-Za-z0-9._:-]{1,128}")
return value
def parse_uuid(value, what):
if not isinstance(value, str) or not UUID_RE.fullmatch(value):
raise bad_request("Некорректный UUID: %s" % what)
return value.lower()
async def read_json_object(request, allowed):
declared = request.headers.get("content-length", "")
if declared.isdigit() and int(declared) > MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
content_type = request.headers.get("content-type", "").split(";")[0].strip().lower()
if content_type and content_type != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается application/json")
body = bytearray()
async for chunk in request.stream():
body += chunk
if len(body) > MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
try:
data = json.loads(bytes(body).decode("utf-8"))
except (UnicodeDecodeError, ValueError):
raise bad_request("Тело запроса не является корректным JSON") from None
if not isinstance(data, dict):
raise bad_request("Тело запроса должно быть JSON-объектом")
if set(data) != set(allowed):
raise bad_request("Ожидаемые поля: " + ", ".join(sorted(allowed)))
return data
def page_params(request):
query = request.query_params
raw_limit = query.getlist("limit")
if len(raw_limit) > 1 or len(query.getlist("cursor")) > 1:
raise bad_request("Параметры limit и cursor можно указать только один раз")
limit = DEFAULT_LIMIT
if raw_limit:
text = raw_limit[0]
if not (text.isascii() and text.isdigit()) or not 1 <= int(text) <= MAX_LIMIT:
raise bad_request("limit должен быть целым числом от 1 до %d" % MAX_LIMIT)
limit = int(text)
return limit, query.get("cursor") or None
def encode_cursor(kind, scope, created_at, item_id):
raw = json.dumps(
{"k": kind, "s": scope,
"t": int(created_at.timestamp() * 1_000_000),
"i": uuid.UUID(str(item_id)).int},
separators=(",", ":"),
)
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=")
def decode_cursor(text, kind, scope):
try:
data = json.loads(base64.urlsafe_b64decode(text + "=" * (-len(text) % 4)))
t, i = data["t"], data["i"]
valid = (data["k"] == kind and data["s"] == scope
and type(t) is int and type(i) is int and t >= 0 and i >= 0)
if not valid:
raise ValueError
return dt.datetime.fromtimestamp(t / 1_000_000, tz=UTC), uuid.UUID(int=i)
except (ValueError, KeyError, TypeError, binascii.Error, OverflowError):
raise bad_request("Некорректный cursor") from None
def page_response(items, limit, kind, scope, rows):
"""items are public JSON dicts; rows are the raw DB rows used for the opaque cursor."""
more = len(items) > limit
window = items[:limit]
last = rows[limit - 1] if more and len(rows) >= limit else None
cursor = (encode_cursor(kind, scope, last["created_at"], last["id"])
if last is not None else None)
return JSONResponse({"items": window, "next_cursor": cursor})
# ---------- authentication and resource access ----------
def current_user(request):
"""Lab2: only an opaque Bearer session identifies the caller; X-User-Id is ignored."""
token = bearer_token(request.headers.get("authorization"))
if not token:
raise unauthorized(BEARER_CHALLENGE)
with db.connection() as conn:
row = conn.execute(
"SELECT u.id, u.username, u.display_name, u.created_at "
"FROM sessions s JOIN users u ON u.id = s.user_id "
"WHERE s.token_hash = %s AND s.expires_at > clock_timestamp()",
(token_hash(token),),
).fetchone()
if row is None:
raise unauthorized(BEARER_CHALLENGE)
return user_public(row)
def authenticated_chat(request, chat_id):
user = current_user(request)
chat_uuid = parse_uuid(chat_id, "chat_id")
with db.connection() as conn:
row = conn.execute(
"SELECT c.id, c.title, c.created_at, "
"array_agg(m.user_id ORDER BY m.user_id) AS member_ids "
"FROM chats c JOIN chat_members m ON m.chat_id = c.id "
"WHERE c.id = %s AND m.user_id = %s GROUP BY c.id",
(chat_uuid, uuid.UUID(user["id"])),
).fetchone()
if row is None:
raise not_found() # unknown and foreign chats look identical
return user, chat_public(row)
# ---------- health ----------
@app.get("/health/live")
async def live():
return {"status": "ok"}
@app.get("/health/ready")
async def ready():
if not db.ready():
raise ApiError(503, "unavailable", "Хранилище данных недоступно")
return {"status": "ok"}
# ---------- users and sessions ----------
@app.post("/api/v1/users")
async def register_user(request: Request):
data = await read_json_object(request, ("username", "display_name", "password"))
username = data["username"]
if not isinstance(username, str) or not USERNAME_RE.fullmatch(username):
raise bad_request("username должен соответствовать [a-z0-9_]{3,32}")
display_name = clean_string(data, "display_name", 100)
password = data["password"]
if not isinstance(password, str) or not 12 <= len(password) <= 128:
raise bad_request("password должен содержать от 12 до 128 символов")
user_id = uuid.uuid4()
try:
with db.transaction() as conn:
conn.execute(
"INSERT INTO users(id, username, display_name, password_hash) VALUES (%s,%s,%s,%s)",
(user_id, username, display_name, hash_password(password)),
)
row = conn.execute("SELECT * FROM users WHERE id = %s", (user_id,)).fetchone()
except psycopg.errors.UniqueViolation:
raise ApiError(409, "conflict", "Имя пользователя уже занято") from None
return JSONResponse(user_public(row), status_code=201)
@app.post("/api/v1/auth/sessions")
async def create_session(request: Request):
credential = parse_basic(request.headers.get("authorization"))
if credential is None:
raise unauthorized(BASIC_CHALLENGE, "Неверные учетные данные")
username, password = credential
with db.connection() as conn:
row = conn.execute("SELECT * FROM users WHERE username = %s", (username,)).fetchone()
if row is None or not verify_password(password, row["password_hash"]):
raise unauthorized(BASIC_CHALLENGE, "Неверные учетные данные")
token = base64.urlsafe_b64encode(os.urandom(32)).decode().rstrip("=")
ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
expires_at = dt.datetime.now(UTC) + dt.timedelta(seconds=ttl)
with db.transaction() as conn:
conn.execute(
"INSERT INTO sessions(token_hash, user_id, expires_at) VALUES (%s,%s,%s)",
(token_hash(token), row["id"], expires_at),
)
return JSONResponse({
"token": token,
"token_type": "Bearer",
"expires_at": utc_text(expires_at),
"user": user_public(row),
}, status_code=201)
@app.delete("/api/v1/auth/sessions/current")
async def revoke_session(request: Request):
token = bearer_token(request.headers.get("authorization"))
if not token:
raise unauthorized(BEARER_CHALLENGE)
with db.transaction() as conn:
result = conn.execute(
"DELETE FROM sessions WHERE token_hash = %s AND expires_at > clock_timestamp()",
(token_hash(token),),
)
if result.rowcount == 0:
raise unauthorized(BEARER_CHALLENGE)
return Response(status_code=204)
@app.get("/api/v1/users/me")
async def get_me(request: Request):
return current_user(request)
# ---------- chats ----------
@app.post("/api/v1/chats")
async def create_chat(request: Request):
user = current_user(request)
data = await read_json_object(request, ("title", "member_ids"))
title = clean_string(data, "title", 100)
raw_members = data["member_ids"]
if not isinstance(raw_members, list) or not 1 <= len(raw_members) <= 100:
raise bad_request("member_ids должен быть списком из 1–100 UUID")
members = [parse_uuid(m, "member_ids") for m in raw_members]
if len(set(members)) != len(members):
raise bad_request("member_ids содержит дубликаты")
if user["id"] not in members:
raise bad_request("member_ids должен содержать вызывающего пользователя")
chat_id = uuid.uuid4()
member_uuids = [uuid.UUID(x) for x in members]
try:
with db.transaction() as conn:
found = conn.execute(
"SELECT id FROM users WHERE id = ANY(%s::uuid[])", (member_uuids,)
).fetchall()
if len(found) != len(member_uuids):
raise bad_request("member_ids содержит неизвестного пользователя")
conn.execute("INSERT INTO chats(id, title) VALUES (%s,%s)", (chat_id, title))
for member in member_uuids:
conn.execute(
"INSERT INTO chat_members(chat_id, user_id) VALUES (%s,%s)",
(chat_id, member),
)
row = conn.execute(
"SELECT c.id, c.title, c.created_at, array_agg(m.user_id ORDER BY m.user_id) AS member_ids "
"FROM chats c JOIN chat_members m ON m.chat_id = c.id WHERE c.id = %s GROUP BY c.id",
(chat_id,),
).fetchone()
except psycopg.errors.ForeignKeyViolation:
raise bad_request("member_ids содержит неизвестного пользователя") from None
return JSONResponse(chat_public(row), status_code=201)
@app.get("/api/v1/chats")
async def list_chats(request: Request):
user = current_user(request)
limit, cursor = page_params(request)
after = decode_cursor(cursor, "chats", user["id"]) if cursor else None
sql = (
"SELECT c.id, c.title, c.created_at, array_agg(m.user_id ORDER BY m.user_id) AS member_ids "
"FROM chats c JOIN chat_members m ON m.chat_id = c.id WHERE m.user_id = %s"
)
params = [uuid.UUID(user["id"])]
if after:
sql += " AND (c.created_at, c.id) > (%s, %s::uuid)"
params.extend([after[0], after[1]])
sql += " GROUP BY c.id ORDER BY c.created_at, c.id LIMIT %s"
params.append(limit + 1)
with db.connection() as conn:
rows = conn.execute(sql, params).fetchall()
items = [chat_public(r) for r in rows]
return page_response(items, limit, "chats", user["id"], rows)
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, request: Request):
_, chat = authenticated_chat(request, chat_id)
return chat
# ---------- messages ----------
@app.post("/api/v1/chats/{chat_id}/messages")
async def create_message(chat_id: str, request: Request):
"""Idempotent POST: the ledger row and the message are committed atomically."""
user, chat = authenticated_chat(request, chat_id) # replay re-checks session and access
data = await read_json_object(request, ("text",))
text = clean_string(data, "text", 4000)
key = idempotency_key(request)
# Canonical body hash: key order does not matter; omitted attachment_ids == [].
canonical = json.dumps({"text": text}, sort_keys=True, separators=(",", ":"))
request_hash = hashlib.sha256(canonical.encode("utf-8")).hexdigest()
scope_path = request.url.path
actor_id = uuid.UUID(user["id"])
for _attempt in range(5):
try:
with db.transaction() as conn:
previous = conn.execute(
"SELECT request_hash, status_code, response_body FROM idempotency_records "
"WHERE user_id=%s AND method=%s AND path=%s AND key=%s FOR UPDATE",
(actor_id, "POST", scope_path, key),
).fetchone()
if previous is not None:
if previous["request_hash"] != request_hash:
raise ApiError(409, "conflict", "Тот же Idempotency-Key использован с другим телом")
return JSONResponse(previous["response_body"], status_code=previous["status_code"])
message_id = uuid.uuid4()
conn.execute(
"INSERT INTO messages(id, chat_id, sender_id, text) VALUES (%s,%s,%s,%s)",
(message_id, uuid.UUID(chat["id"]), actor_id, text),
)
row = conn.execute("SELECT * FROM messages WHERE id = %s", (message_id,)).fetchone()
body = message_public(row)
conn.execute(
"INSERT INTO idempotency_records"
"(user_id, method, path, key, request_hash, status_code, response_body) "
"VALUES (%s,%s,%s,%s,%s,%s,%s::jsonb)",
(actor_id, "POST", scope_path, key, request_hash, 201,
json.dumps(body, ensure_ascii=False)),
)
return JSONResponse(body, status_code=201)
except psycopg.errors.UniqueViolation:
# Another replica won the race for this key. Roll back and read its
# committed response on the next attempt instead of creating a duplicate.
continue
raise ApiError(409, "conflict", "Не удалось зафиксировать Idempotency-Key")
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, request: Request):
_, chat = authenticated_chat(request, chat_id)
limit, cursor = page_params(request)
after = decode_cursor(cursor, "messages", chat["id"]) if cursor else None
sql = "SELECT * FROM messages WHERE chat_id = %s"
params = [uuid.UUID(chat["id"])]
if after:
sql += " AND (created_at, id) > (%s, %s::uuid)"
params.extend([after[0], after[1]])
sql += " ORDER BY created_at, id LIMIT %s"
params.append(limit + 1)
with db.connection() as conn:
rows = conn.execute(sql, params).fetchall()
items = [message_public(r) for r in rows]
return page_response(items, limit, "messages", chat["id"], rows)
+66
View File
@@ -0,0 +1,66 @@
"""Password KDF and HTTP credential parsing (Basic / opaque Bearer)."""
import base64
import binascii
import hashlib
import hmac
import os
import re
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}\Z")
SCRYPT_N = 2 ** 14
SCRYPT_R = 8
SCRYPT_P = 1
SCRYPT_LEN = 32
def hash_password(password):
salt = os.urandom(16)
derived = hashlib.scrypt(
password.encode("utf-8"), salt=salt, n=SCRYPT_N, r=SCRYPT_R, p=SCRYPT_P, dklen=SCRYPT_LEN
)
return "scrypt$%d$%d$%d$%s$%s" % (
SCRYPT_N, SCRYPT_R, SCRYPT_P, salt.hex(), derived.hex()
)
def verify_password(password, stored):
try:
scheme, n, r, p, salt_hex, digest_hex = stored.split("$")
if scheme != "scrypt":
return False
derived = hashlib.scrypt(
password.encode("utf-8"),
salt=bytes.fromhex(salt_hex),
n=int(n), r=int(r), p=int(p), dklen=len(bytes.fromhex(digest_hex)),
)
return hmac.compare_digest(derived, bytes.fromhex(digest_hex))
except (ValueError, TypeError):
return False
def token_hash(token):
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def parse_basic(header):
"""Return (username, password) or None. Colon inside the password is allowed."""
if not header or not header.lower().startswith("basic "):
return None
encoded = header[6:].strip()
try:
raw = base64.b64decode(encoded, validate=True).decode("utf-8")
except (ValueError, UnicodeDecodeError, binascii.Error):
return None
if ":" not in raw:
return None
username, password = raw.split(":", 1)
if not USERNAME_RE.fullmatch(username) or not 12 <= len(password) <= 128:
return None
return username, password
def bearer_token(header):
if not header or not header.lower().startswith("bearer "):
return None
token = header[7:].strip()
return token or None
+71
View File
@@ -0,0 +1,71 @@
# Lab3 level 3: single public entry point (nginx) -> 2 interchangeable API replicas
# -> one shared PostgreSQL database. Sessions and the idempotency ledger live in the DB.
services:
db:
image: postgres:16-alpine
restart: unless-stopped
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set a synthetic local password in .env}
POSTGRES_DB: ${POSTGRES_DB:-messenger}
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
interval: 3s
timeout: 3s
retries: 20
api1:
build: .
restart: unless-stopped
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_ENV: lab
INSTANCE_ALIAS: api1
DATABASE_URL: ${DATABASE_URL:?set DATABASE_URL in .env}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
depends_on:
db:
condition: service_healthy
healthcheck:
test: ["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)"]
interval: 5s
timeout: 3s
retries: 20
api2:
build: .
restart: unless-stopped
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_ENV: lab
INSTANCE_ALIAS: api2
DATABASE_URL: ${DATABASE_URL:?set DATABASE_URL in .env}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
depends_on:
db:
condition: service_healthy
healthcheck:
test: ["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)"]
interval: 5s
timeout: 3s
retries: 20
lb:
image: nginx:1.27-alpine
restart: unless-stopped
volumes:
- ./infra/nginx.conf:/etc/nginx/nginx.conf:ro
ports:
- "8080:8080"
depends_on:
api1:
condition: service_healthy
api2:
condition: service_healthy
volumes:
pgdata:
+112
View File
@@ -0,0 +1,112 @@
=== 1. Start the whole stack from a clean clone ===
config --quiet: OK
Image mtusi2026lab3-api1 Built
Image mtusi2026lab3-api2 Built
Container mtusi2026lab3-db-1 Running
Container mtusi2026lab3-api2-1 Recreated
Container mtusi2026lab3-api1-1 Recreated
Container mtusi2026lab3-lb-1 Running
Container mtusi2026lab3-db-1 Healthy
Container mtusi2026lab3-db-1 Healthy
Container mtusi2026lab3-api1-1 Started
Container mtusi2026lab3-api2-1 Started
Container mtusi2026lab3-api2-1 Healthy
Container mtusi2026lab3-api1-1 Healthy
=== 2. Containers (one public LB, two API replicas, one DB) ===
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab3-api1-1 mtusi2026lab3-api1 "python -m app" api1 7 seconds ago Up 5 seconds (healthy) 8080/tcp
mtusi2026lab3-api2-1 mtusi2026lab3-api2 "python -m app" api2 7 seconds ago Up 5 seconds (healthy) 8080/tcp
mtusi2026lab3-db-1 postgres:16-alpine "docker-entrypoint.sтАж" db 6 minutes ago Up 47 seconds (healthy) 5432/tcp
mtusi2026lab3-lb-1 nginx:1.27-alpine "/docker-entrypoint.тАж" lb 6 minutes ago Up 4 minutes 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
=== 3. X-Instance-Id seen by one client through the LB (same token profile) ===
x-instance-id: api1
x-instance-id: api1
x-instance-id: api2
x-instance-id: api1
x-instance-id: api2
x-instance-id: api1
x-instance-id: api2
x-instance-id: api1
=== 4. Public smoke ===
ready after 0 s
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
=== 5. Rows and idempotency ledger BEFORE restart ===
users | sessions | chats | messages | idem
-------+----------+-------+----------+------
36 | 31 | 12 | 205 | 205
(1 row)
name
--------------
001_init.sql
(1 row)
=== 6. Persistence hook (restart DB + both API replicas, volumes preserved) ===
cmd : Container mtusi2026lab3-api1-1 Restarting
C:\Users\Tankist\AppData\Local\Temp\opencode\capture_lab3.ps1:46 знак:3
+ cmd /c 'scripts\restart.cmd' 2>&1
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo : NotSpecified: ( Container mtus...1-1 Restarting :String) [], RemoteException
+ FullyQualifiedErrorId : NativeCommandError
Container mtusi2026lab3-db-1 Restarting
Container mtusi2026lab3-api2-1 Restarting
Container mtusi2026lab3-db-1 Started
Container mtusi2026lab3-api2-1 Started
Container mtusi2026lab3-api1-1 Started
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab3-api1-1 mtusi2026lab3-api1 "python -m app" api1 10 seconds ago Up Less than a second (health: starting) 8080/tcp
mtusi2026lab3-api2-1 mtusi2026lab3-api2 "python -m app" api2 10 seconds ago Up Less than a second (health: starting) 8080/tcp
mtusi2026lab3-db-1 postgres:16-alpine "docker-entrypoint.sтАж" db 6 minutes ago Up Less than a second (health: starting) 5432/tcp
mtusi2026lab3-lb-1 nginx:1.27-alpine "/docker-entrypoint.тАж" lb 6 minutes ago Up 4 minutes 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
=== 7. Persistence test with the same token ===
ready after 6 s
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
ready after 0 s
=== 8. Failover hook (stop exactly one API replica, then restore it) ===
cmd : Container mtusi2026lab3-api1-1 Stopping
C:\Users\Tankist\AppData\Local\Temp\opencode\capture_lab3.ps1:57 знак:3
+ cmd /c 'set TARGET_INSTANCE_ID=api1&& scripts\stop-one.cmd' 2>&1
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo : NotSpecified: ( Container mtus...pi1-1 Stopping :String) [], RemoteException
+ FullyQualifiedErrorId : NativeCommandError
Container mtusi2026lab3-api1-1 Stopped
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab3-api2-1 mtusi2026lab3-api2 "python -m app" api2 24 seconds ago Up 7 seconds (healthy) 8080/tcp
mtusi2026lab3-db-1 postgres:16-alpine "docker-entrypoint.sтАж" db 6 minutes ago Up 7 seconds (healthy) 5432/tcp
mtusi2026lab3-lb-1 nginx:1.27-alpine "/docker-entrypoint.тАж" lb 6 minutes ago Up 4 minutes 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
ready after 0 s
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab3-api1-1 mtusi2026lab3-api1 "python -m app" api1 33 seconds ago Up 8 seconds (healthy) 8080/tcp
mtusi2026lab3-api2-1 mtusi2026lab3-api2 "python -m app" api2 33 seconds ago Up 16 seconds (healthy) 8080/tcp
mtusi2026lab3-db-1 postgres:16-alpine "docker-entrypoint.sтАж" db 6 minutes ago Up 16 seconds (healthy) 5432/tcp
mtusi2026lab3-lb-1 nginx:1.27-alpine "/docker-entrypoint.тАж" lb 6 minutes ago Up 5 minutes 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
=== 9. Failover test through the LB ===
ready after 0 s
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 106, "failed_attempts": 2, "first_recovery_seconds": 0.608}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
ready after 0 s
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab3-api1-1 mtusi2026lab3-api1 "python -m app" api1 52 seconds ago Up Less than a second (health: starting) 8080/tcp
mtusi2026lab3-api2-1 mtusi2026lab3-api2 "python -m app" api2 52 seconds ago Up 34 seconds (healthy) 8080/tcp
mtusi2026lab3-db-1 postgres:16-alpine "docker-entrypoint.sтАж" db 7 minutes ago Up 34 seconds (healthy) 5432/tcp
mtusi2026lab3-lb-1 nginx:1.27-alpine "/docker-entrypoint.тАж" lb 7 minutes ago Up 5 minutes 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
=== 10. Own unit tests and offline check ===
----------------------------------------------------------------------
Ran 11 tests in 0.270s
OK
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+30
View File
@@ -0,0 +1,30 @@
events {
worker_connections 1024;
}
http {
access_log /dev/stdout;
error_log /dev/stderr warn;
upstream api_backend {
server api1:8080 max_fails=1 fail_timeout=5s;
server api2:8080 max_fails=1 fail_timeout=5s;
}
server {
listen 8080;
location / {
proxy_pass http://api_backend;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Connection "";
# Retry the other replica on a transport failure or a 5xx from a dying backend.
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_connect_timeout 2s;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
}
}
}
+58
View File
@@ -0,0 +1,58 @@
-- Lab2 initial schema. Applied once by app/db.py; safe to keep volumes on restart.
-- Source of truth for users, chats, memberships, messages and sessions is PostgreSQL.
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY,
username TEXT NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name TEXT NOT NULL CHECK (length(display_name) BETWEEN 1 AND 100),
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL CHECK (length(title) BETWEEN 1 AND 100),
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS ix_chat_members_user ON chat_members (user_id, chat_id);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id),
text TEXT NOT NULL CHECK (length(text) BETWEEN 1 AND 4000),
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
-- Keyset pagination reads strictly one (created_at, id) window; no full-history scan.
CREATE INDEX IF NOT EXISTS ix_messages_history ON messages (chat_id, created_at, id);
CREATE TABLE IF NOT EXISTS sessions (
token_hash TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX IF NOT EXISTS ix_sessions_user ON sessions (user_id);
CREATE INDEX IF NOT EXISTS ix_sessions_expiry ON sessions (expires_at);
-- Shared idempotency ledger for POST /chats/{id}/messages (lab3+).
-- Uniqueness scope: user + HTTP method + chat path + key. Stored alongside the
-- message insert in the SAME transaction, so a retry cannot create a duplicate.
CREATE TABLE IF NOT EXISTS idempotency_records (
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
method TEXT NOT NULL,
path TEXT NOT NULL,
key TEXT NOT NULL,
request_hash TEXT NOT NULL,
status_code INTEGER NOT NULL,
response_body JSONB NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(),
PRIMARY KEY (user_id, method, path, key)
);
CREATE INDEX IF NOT EXISTS ix_idempotency_created ON idempotency_records (created_at);
+3
View File
@@ -0,0 +1,3 @@
fastapi==0.135.3
uvicorn==0.44.0
psycopg[binary]==3.3.3
+5
View File
@@ -0,0 +1,5 @@
@echo off
REM Windows equivalent of scripts/restart.sh for the local persistence hook.
cd /d "%~dp0.."
docker compose --env-file .env restart db api1 api2
exit /b %ERRORLEVEL%
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
# Explicit persistence hook for lab3.
# Restart both API replicas and PostgreSQL. Volumes are preserved: no down -v,
# no flush, no re-seed. The load balancer stays in front of the replicas.
cd "$(dirname "$0")/.."
docker compose restart db api1 api2
+10
View File
@@ -0,0 +1,10 @@
@echo off
REM Windows equivalent of scripts/stop-one.sh for the local failover hook.
cd /d "%~dp0.."
if "%TARGET_INSTANCE_ID%"=="api1" goto stop
if "%TARGET_INSTANCE_ID%"=="api2" goto stop
echo unknown target instance: %TARGET_INSTANCE_ID% >&2
exit /b 1
:stop
docker compose --env-file .env stop %TARGET_INSTANCE_ID%
exit /b %ERRORLEVEL%
+11
View File
@@ -0,0 +1,11 @@
#!/bin/sh
set -eu
# Explicit failover hook: stop exactly ONE API replica selected by the test.
# TARGET_INSTANCE_ID is the X-Instance-Id served by that replica (api1 or api2).
# DB, volume and load balancer are untouched. Return quickly; leave the replica stopped.
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
case "$TARGET_INSTANCE_ID" in
api1|api2) docker compose stop "$TARGET_INSTANCE_ID" ;;
*) echo "unknown target instance: $TARGET_INSTANCE_ID" >&2; exit 1 ;;
esac
+91
View File
@@ -0,0 +1,91 @@
"""Own tests for the security helpers and keyset cursors (stdlib unittest)."""
import base64
import datetime as dt
import json
import sys
import unittest
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from app import main as api
from app.security import (bearer_token, hash_password, parse_basic,
token_hash, verify_password)
class PasswordTests(unittest.TestCase):
def test_kdf_round_trip_and_uniqueness(self):
first = hash_password("T3st-passphrase-123")
second = hash_password("T3st-passphrase-123")
self.assertNotEqual(first, second, "salt must be unique")
self.assertTrue(first.startswith("scrypt$"))
self.assertTrue(verify_password("T3st-passphrase-123", first))
self.assertFalse(verify_password("wrong-password", first))
def test_unicode_and_colon_password(self):
secret = "пароль:с:двоеточием-123"
stored = hash_password(secret)
self.assertTrue(verify_password(secret, stored))
self.assertFalse(verify_password("пароль", stored))
class CredentialTests(unittest.TestCase):
def test_basic_colon_inside_password(self):
raw = "u_alice_123:T3st-with:colon-12345"
header = "Basic " + base64.b64encode(raw.encode()).decode()
self.assertEqual(parse_basic(header), ("u_alice_123", "T3st-with:colon-12345"))
def test_basic_rejects_short_password_and_bad_scheme(self):
raw = "u_alice_123:short"
self.assertIsNone(parse_basic("Basic " + base64.b64encode(raw.encode()).decode()))
self.assertIsNone(parse_basic("Bearer abcdef"))
def test_bearer_only(self):
self.assertEqual(bearer_token("Bearer abc"), "abc")
self.assertIsNone(bearer_token("Basic abc"))
self.assertIsNone(bearer_token(None))
def test_token_hash_is_stable_and_not_the_token(self):
token = "s" * 43
self.assertEqual(token_hash(token), token_hash(token))
self.assertNotEqual(token_hash(token), token)
class IdempotencyTests(unittest.TestCase):
def test_key_pattern(self):
self.assertIsNotNone(api.IDEMPOTENCY_KEY_RE.fullmatch('abc-123.XYZ:9_'))
self.assertIsNone(api.IDEMPOTENCY_KEY_RE.fullmatch('bad key'))
self.assertIsNone(api.IDEMPOTENCY_KEY_RE.fullmatch(''))
def test_canonical_body_hash_ignores_key_order(self):
import hashlib
a = json.dumps({'text': 'Привет'}, sort_keys=True, separators=(',', ':'))
b = json.dumps({'text': 'Привет'}, separators=(',', ':'))
self.assertEqual(hashlib.sha256(a.encode()).hexdigest(),
hashlib.sha256(b.encode()).hexdigest())
class CursorTests(unittest.TestCase):
def test_round_trip(self):
created = dt.datetime(2026, 11, 16, 12, 0, 0, 123456, tzinfo=dt.timezone.utc)
item_id = uuid.uuid4()
encoded = api.encode_cursor("messages", "scope-1", created, item_id)
back_created, back_id = api.decode_cursor(encoded, "messages", "scope-1")
self.assertEqual(back_created, created)
self.assertEqual(back_id, item_id)
def test_wrong_scope_rejected(self):
created = dt.datetime.now(dt.timezone.utc)
encoded = api.encode_cursor("messages", "chat-A", created, uuid.uuid4())
with self.assertRaises(api.ApiError):
api.decode_cursor(encoded, "messages", "chat-B")
def test_garbage_rejected(self):
with self.assertRaises(api.ApiError):
api.decode_cursor("not-a-cursor", "messages", "chat-A")
if __name__ == "__main__":
unittest.main(verbosity=2)