From de55dd1d8a981078a906d41934a6c142b477a47e Mon Sep 17 00:00:00 2001 From: Sona Date: Tue, 10 Nov 2026 01:25:06 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0?= =?UTF-8?q?=D1=86=D0=B8=D1=8F=20=D0=9B=D0=A0=203=20=D0=BD=D0=B0=20=D0=BE?= =?UTF-8?q?=D1=86=D0=B5=D0=BD=D0=BA=D1=83=203:=20HAProxy,=202=20=D1=80?= =?UTF-8?q?=D0=B5=D0=BF=D0=BB=D0=B8=D0=BA=D0=B8=20API,=20=D0=B8=D0=B4?= =?UTF-8?q?=D0=B5=D0=BC=D0=BF=D0=BE=D1=82=D0=B5=D0=BD=D1=82=D0=BD=D0=BE?= =?UTF-8?q?=D1=81=D1=82=D1=8C,=20evidence?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 26 ++ compose.yaml | 88 +++++ evidence/failover-1-ps.txt | 7 + evidence/failover-1.txt | 4 + evidence/failover-2-ps.txt | 7 + evidence/failover-2.txt | 4 + evidence/instances.txt | 2 + evidence/persistence.txt | 3 + evidence/ps-before.txt | 7 + evidence/smoke.txt | 2 + infra/haproxy/haproxy.cfg | 35 ++ migrations/001_init.sql | 63 ++++ migrations/002_idempotency.sql | 13 + requirements.txt | 16 + scripts/restart.sh | 7 + scripts/show-instances.sh | 12 + scripts/stop-one.sh | 14 + src/auth.py | 87 +++++ src/cache.py | 82 +++++ src/chats.py | 255 ++++++++++++++ src/common.py | 30 ++ src/config.py | 29 ++ src/db.py | 56 +++ src/main.py | 187 ++++++++++ src/migrate.py | 19 ++ student_tests/test_lab2.py | 585 ++++++++++++++++++++++++++++++++ student_tests/test_level4.py | 195 +++++++++++ student_tests/test_lifecycle.py | 68 ++++ student_tests/test_sigterm.py | 129 +++++++ 29 files changed, 2032 insertions(+) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 evidence/failover-1-ps.txt create mode 100644 evidence/failover-1.txt create mode 100644 evidence/failover-2-ps.txt create mode 100644 evidence/failover-2.txt create mode 100644 evidence/instances.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/ps-before.txt create mode 100644 evidence/smoke.txt create mode 100644 infra/haproxy/haproxy.cfg create mode 100644 migrations/001_init.sql create mode 100644 migrations/002_idempotency.sql create mode 100644 requirements.txt create mode 100755 scripts/restart.sh create mode 100755 scripts/show-instances.sh create mode 100755 scripts/stop-one.sh create mode 100644 src/auth.py create mode 100644 src/cache.py create mode 100644 src/chats.py create mode 100644 src/common.py create mode 100644 src/config.py create mode 100644 src/db.py create mode 100644 src/main.py create mode 100644 src/migrate.py create mode 100644 student_tests/test_lab2.py create mode 100644 student_tests/test_level4.py create mode 100644 student_tests/test_lifecycle.py create mode 100644 student_tests/test_sigterm.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..52a4ede3 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,26 @@ +FROM python:3.12.7-slim@sha256:60d9996b6a8a3689d36db740b49f4327be3be09a21122bd02fb8895abb38b50d + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 + +WORKDIR /app + +RUN groupadd --system app && \ + useradd --system --gid app --create-home app + +COPY requirements.txt /app/requirements.txt +RUN pip install --no-cache-dir --timeout 60 -r requirements.txt + +COPY --chown=app:app src/ /app/src/ +COPY --chown=app:app migrations/ /app/migrations/ + +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \ + CMD python -c "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2)" || exit 1 + +CMD ["sh", "-c", "exec uvicorn src.main:app --host \"${APP_HOST}\" --port \"${APP_PORT}\" --timeout-graceful-shutdown 8"] \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..6f6756c8 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,88 @@ +name: mtusi-lab3 + +services: + postgres: + image: postgres:16.6-alpine + restart: unless-stopped + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + + valkey: + image: valkey/valkey:8.0.1-alpine + restart: unless-stopped + command: ["valkey-server", "--save", "", "--appendonly", "no", "--maxmemory", "64mb", "--maxmemory-policy", "allkeys-lru"] + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + + # Одноразовая задача: применяет миграции и завершается. Реплики API миграции не запускают + migrate: + build: . + image: mtusi-messenger:lab3 + restart: "no" + command: ["python", "-m", "src.migrate"] + depends_on: + postgres: + condition: service_healthy + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: + - database_url + + # Реплики: число задаётся API_REPLICAS (по умолчанию 2). Без container_name и без published-портов + api: + image: mtusi-messenger:lab3 + pull_policy: never + restart: unless-stopped + deploy: + replicas: ${API_REPLICAS:-2} + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_started + migrate: + condition: service_completed_successfully + environment: + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL: redis://valkey:6379/0 + secrets: + - database_url + expose: + - "8080" + + # Единственная публичная точка входа + lb: + image: haproxy:3.0.7-alpine + restart: unless-stopped + depends_on: + - api + volumes: + - ./infra/haproxy:/usr/local/etc/haproxy:ro + ports: + - "127.0.0.1:8080:8080" + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + +volumes: + pgdata: \ No newline at end of file diff --git a/evidence/failover-1-ps.txt b/evidence/failover-1-ps.txt new file mode 100644 index 00000000..9e0785a4 --- /dev/null +++ b/evidence/failover-1-ps.txt @@ -0,0 +1,7 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab3-api-1 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api About an hour ago Exited (0) 28 seconds ago +mtusi-lab3-api-2 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api About an hour ago Up About an hour (healthy) 8080/tcp +mtusi-lab3-lb-1 haproxy:3.0.7-alpine "docker-entrypoint.s…" lb About an hour ago Up About an hour 127.0.0.1:8080->8080/tcp +mtusi-lab3-migrate-1 mtusi-messenger:lab3 "python -m src.migra…" migrate About an hour ago Exited (0) About an hour ago +mtusi-lab3-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres About an hour ago Up About an hour (healthy) 5432/tcp +mtusi-lab3-valkey-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" valkey About an hour ago Up About an hour (healthy) 6379/tcp diff --git a/evidence/failover-1.txt b/evidence/failover-1.txt new file mode 100644 index 00000000..d0501d8d --- /dev/null +++ b/evidence/failover-1.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 122, "failed_attempts": 0, "first_recovery_seconds": 2.036} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/failover-2-ps.txt b/evidence/failover-2-ps.txt new file mode 100644 index 00000000..8199d3f6 --- /dev/null +++ b/evidence/failover-2-ps.txt @@ -0,0 +1,7 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab3-api-1 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api 2 hours ago Up 58 seconds (healthy) 8080/tcp +mtusi-lab3-api-2 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api 2 hours ago Exited (0) 21 seconds ago +mtusi-lab3-lb-1 haproxy:3.0.7-alpine "docker-entrypoint.s…" lb About an hour ago Up About an hour 127.0.0.1:8080->8080/tcp +mtusi-lab3-migrate-1 mtusi-messenger:lab3 "python -m src.migra…" migrate 2 hours ago Exited (0) 58 seconds ago +mtusi-lab3-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres About an hour ago Up About an hour (healthy) 5432/tcp +mtusi-lab3-valkey-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" valkey 2 hours ago Up About an hour (healthy) 6379/tcp diff --git a/evidence/failover-2.txt b/evidence/failover-2.txt new file mode 100644 index 00000000..4d93eeac --- /dev/null +++ b/evidence/failover-2.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 121, "failed_attempts": 0, "first_recovery_seconds": 1.569} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/instances.txt b/evidence/instances.txt new file mode 100644 index 00000000..dce0509a --- /dev/null +++ b/evidence/instances.txt @@ -0,0 +1,2 @@ + 5 x-instance-id: 98cca609117d + 5 x-instance-id: bb44a95c7f25 diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..793b001d --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/ps-before.txt b/evidence/ps-before.txt new file mode 100644 index 00000000..f20313a2 --- /dev/null +++ b/evidence/ps-before.txt @@ -0,0 +1,7 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab3-api-1 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api 16 minutes ago Up 16 minutes (healthy) 8080/tcp +mtusi-lab3-api-2 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api 16 minutes ago Up 16 minutes (healthy) 8080/tcp +mtusi-lab3-lb-1 haproxy:3.0.7-alpine "docker-entrypoint.s…" lb About a minute ago Up About a minute 127.0.0.1:8080->8080/tcp +mtusi-lab3-migrate-1 mtusi-messenger:lab3 "python -m src.migra…" migrate 16 minutes ago Exited (0) About a minute ago +mtusi-lab3-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 12 minutes ago Up 12 minutes (healthy) 5432/tcp +mtusi-lab3-valkey-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" valkey 16 minutes ago Up 16 minutes (healthy) 6379/tcp diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..44e41deb --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..58bbf906 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,35 @@ +global + log stdout format raw local0 + +defaults + mode http + log global + option httplog + timeout connect 1s + timeout client 30s + timeout server 10s + retries 3 + option redispatch + +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + hold other 1s + hold nx 1s + hold timeout 1s + accepted_payload_size 8192 + +frontend public + bind :8080 + default_backend api + +backend api + balance roundrobin + option httpchk + http-check send meth GET uri /health/ready + http-check expect status 200 + default-server check inter 1s fall 2 rise 2 resolvers docker init-addr none + server-template api 1-8 api:8080 diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..a43b5358 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,63 @@ +-- 001_init: базовая схема лабы 2. Повторный запуск безопасен (IF NOT EXISTS). + +CREATE TABLE IF NOT EXISTS users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, -- Argon2id, никогда не отдаётся в API + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK ( + char_length(display_name) BETWEEN 1 AND 100 AND btrim(display_name) <> '' + ) +); + +CREATE TABLE IF NOT EXISTS chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT chats_title_len CHECK ( + char_length(title) BETWEEN 1 AND 100 AND btrim(title) <> '' + ) +); + +-- Порядок списка чатов: (created_at, id) +CREATE INDEX IF NOT EXISTS chats_created_idx ON chats (created_at, id); + +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), + position smallint NOT NULL, -- порядок member_ids как в запросе + PRIMARY KEY (chat_id, user_id) +); + +-- Список чатов пользователя и проверка членства +CREATE INDEX IF NOT EXISTS chat_members_user_idx 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, + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT messages_text_len CHECK ( + char_length(text) BETWEEN 1 AND 4000 AND btrim(text) <> '' + ) +); + +-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +-- ORDER BY created_at, id LIMIT n -> index scan без сортировки и полного прохода +CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id); + +CREATE TABLE IF NOT EXISTS sessions ( + token_hash bytea PRIMARY KEY, -- SHA-256 токена; сам токен не хранится + user_id uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT now(), + expires_at timestamptz NOT NULL, + revoked_at timestamptz, + CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at) +); + +CREATE INDEX IF NOT EXISTS sessions_user_idx ON sessions (user_id); +CREATE INDEX IF NOT EXISTS sessions_expires_idx ON sessions (expires_at); \ No newline at end of file diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..ba0c7db7 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,13 @@ +-- 002: общая идемпотентность отправки сообщений +CREATE TABLE IF NOT EXISTS idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id), + method text NOT NULL, + path text NOT NULL, + idem_key text NOT NULL, + request_hash bytea NOT NULL, -- SHA-256 канонического тела + message_id uuid REFERENCES messages (id), + created_at timestamptz NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, method, path, idem_key) +); + +CREATE INDEX IF NOT EXISTS idempotency_created_idx ON idempotency_keys (created_at); \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..23aaa3e5 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,16 @@ +annotated-types==0.8.0 +anyio==4.15.1 +click==8.5.0 +fastapi==0.115.2 +h11==0.16.0 +idna==3.20 +pydantic==2.14.1 +pydantic-core==2.50.1 +starlette==0.40.0 +typing-extensions==4.16.0 +typing-inspection==0.4.4 +uvicorn==0.32.0 +asyncpg==0.30.0 +argon2-cffi==23.1.0 +argon2-cffi-bindings==21.2.0 +redis==5.2.1 \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..edf94b95 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,7 @@ +#!/bin/sh +# Перезапуск API и хранилищ с сохранением volume (никаких down -v). +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env stop api +docker compose --env-file .env restart postgres valkey +docker compose --env-file .env start api \ No newline at end of file diff --git a/scripts/show-instances.sh b/scripts/show-instances.sh new file mode 100755 index 00000000..15c74d5c --- /dev/null +++ b/scripts/show-instances.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# Одна сессия, 10 запросов через LB: в ответах должны быть >=2 разных X-Instance-Id. +set -eu +BASE="${BASE_URL:-http://localhost:8080}" +U="demo_$(date +%s)" +curl -sf -X POST "$BASE/api/v1/users" -H 'Content-Type: application/json' \ + -d "{\"username\":\"$U\",\"display_name\":\"Demo\",\"password\":\"demo-password-123\"}" >/dev/null +TOKEN=$(curl -sf -X POST "$BASE/api/v1/auth/sessions" -u "$U:demo-password-123" \ + | python3 -c 'import sys,json; print(json.load(sys.stdin)["token"])') +for i in 1 2 3 4 5 6 7 8 9 10; do + curl -si "$BASE/api/v1/users/me" -H "Authorization: Bearer $TOKEN" | grep -i '^x-instance-id' +done | sort | uniq -c \ No newline at end of file diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..6939ede0 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,14 @@ +#!/bin/sh +# Останавливает ОДНУ API-реплику по TARGET_INSTANCE_ID (= hostname контейнера = короткий ID) +# Реплика остаётся остановленной. БД, LB и volumes не затрагиваются +set -eu +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" +case "$TARGET_INSTANCE_ID" in + ""|*[!A-Za-z0-9_.-]*) echo "bad instance id" >&2; exit 2 ;; +esac +cd "$(dirname "$0")/.." +CID=$(docker ps --filter "label=com.docker.compose.service=api" \ + --filter "id=$TARGET_INSTANCE_ID" --format '{{.ID}}') +[ -n "$CID" ] || { echo "no running api container for this instance" >&2; exit 1; } +docker stop -t 2 "$CID" >/dev/null +echo "stopped api container $CID" >&2 \ No newline at end of file diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..4653429d --- /dev/null +++ b/src/auth.py @@ -0,0 +1,87 @@ +import asyncio +import base64 +import binascii +import hashlib +import secrets +from typing import Optional, Tuple + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError +from fastapi import HTTPException, Request + +_hasher = PasswordHasher() +# Хеш-заглушка: для несуществующего пользователя тратим столько же времени, сколько для существующего. +_DUMMY_HASH = _hasher.hash("dummy-password-for-timing") + +BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'} +BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} + + +async def hash_password(password: str) -> str: + return await asyncio.to_thread(_hasher.hash, password) # Argon2 грузит CPU, не блокируем event loop + + +async def verify_password(stored_hash: Optional[str], password: str) -> bool: + try: + return await asyncio.to_thread(_hasher.verify, stored_hash or _DUMMY_HASH, password) + except (VerificationError, InvalidHashError): + return False + + +def new_token() -> str: + return secrets.token_urlsafe(32) # 256 бит случайности + + +def token_hash(token: str) -> bytes: + return hashlib.sha256(token.encode()).digest() + + +def parse_basic(header: Optional[str]) -> Optional[Tuple[str, str]]: + if not header: + return None + scheme, _, value = header.partition(" ") + if scheme.lower() != "basic" or not value: + return None + try: + raw = base64.b64decode(value.strip(), validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError, ValueError): + return None + username, sep, password = raw.partition(":") # двоеточие в пароле допустимо + return (username, password) if sep else None + + +def parse_bearer(header: Optional[str]) -> Optional[str]: + if not header: + return None + scheme, _, value = header.partition(" ") + value = value.strip() + if scheme.lower() != "bearer" or not value or len(value) > 512: + return None + return value + + +_SESSION_SQL = """ +SELECT u.id, u.username, u.display_name, u.created_at, + EXTRACT(EPOCH FROM (s.expires_at - now())) AS remaining +FROM sessions s JOIN users u ON u.id = s.user_id +WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now() +""" + + +async def current_user(request: Request): + # Только Bearer. Сначала кэш, при промахе или сбое - PostgreSQL (источник истины). + token = parse_bearer(request.headers.get("Authorization")) + if token is None: + raise HTTPException(401, headers=BEARER_CHALLENGE) + digest = token_hash(token) + cache = request.app.state.cache + + user = await cache.get(digest) + if user is None: + row = await request.app.state.pool.fetchrow(_SESSION_SQL, digest) + if row is None: + raise HTTPException(401, headers=BEARER_CHALLENGE) + user = {k: row[k] for k in ("id", "username", "display_name", "created_at")} + await cache.put(digest, user, int(row["remaining"])) + request.state.token_hash = digest + return user \ No newline at end of file diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..a2f14c8d --- /dev/null +++ b/src/cache.py @@ -0,0 +1,82 @@ +import asyncio +import json +import logging +import time +import uuid +from datetime import datetime +from typing import Optional + +import redis.asyncio as redis +from redis.exceptions import RedisError + +from . import config +from .common import iso + +logger = logging.getLogger("messenger") + +_FAILURES = (RedisError, OSError, asyncio.TimeoutError) +_RETRY_AFTER = 5.0 # после сбоя 5 секунд не обращаемся к кэшу, чтобы не ждать таймаут на каждом запросе + + +def _key(digest: bytes) -> str: + return "sess:" + digest.hex() + + +class SessionCache: + """Кэш проверенных сессий. Любой сбой = промах: ответ берётся из PostgreSQL.""" + + def __init__(self, url: str): + self._client = ( + redis.Redis.from_url( + url, decode_responses=True, + socket_timeout=config.CACHE_TIMEOUT, socket_connect_timeout=config.CACHE_TIMEOUT, + ) if url else None + ) + self._down_until = 0.0 + + def _usable(self) -> bool: + return self._client is not None and time.monotonic() >= self._down_until + + def _mark_down(self, exc: Exception) -> None: + self._down_until = time.monotonic() + _RETRY_AFTER + logger.warning("Cache unavailable, bypassing: %s", type(exc).__name__) + + async def get(self, digest: bytes) -> Optional[dict]: + if not self._usable(): + return None + try: + raw = await self._client.get(_key(digest)) + except _FAILURES as exc: + self._mark_down(exc) + return None + if raw is None: + return None + try: + d = json.loads(raw) + return {"id": uuid.UUID(d["id"]), "username": d["username"], + "display_name": d["display_name"], "created_at": datetime.fromisoformat(d["created_at"])} + except (ValueError, KeyError): + return None + + async def put(self, digest: bytes, user: dict, remaining_seconds: int) -> None: + ttl = min(remaining_seconds, config.CACHE_TTL_SECONDS) # кэш никогда не живёт дольше сессии + if ttl < 1 or not self._usable(): + return + value = json.dumps({"id": str(user["id"]), "username": user["username"], + "display_name": user["display_name"], "created_at": iso(user["created_at"])}) + try: + await self._client.set(_key(digest), value, ex=ttl) + except _FAILURES as exc: + self._mark_down(exc) + + async def delete(self, digest: bytes) -> None: + if not self._usable(): + return + try: + await self._client.delete(_key(digest)) + except _FAILURES as exc: + self._mark_down(exc) + + async def close(self) -> None: + if self._client is not None: + await self._client.aclose() \ No newline at end of file diff --git a/src/chats.py b/src/chats.py new file mode 100644 index 00000000..267b4e46 --- /dev/null +++ b/src/chats.py @@ -0,0 +1,255 @@ +import base64 +import json +import uuid +from datetime import datetime +from typing import List, Optional, Tuple + +import asyncpg +from fastapi import APIRouter, Depends, Query, Request +from pydantic import BaseModel, ConfigDict, Field + +from .auth import current_user +from .common import iso, make_error_response + +import hashlib +import re +from . import config + +router = APIRouter() + +IDEMPOTENCY_KEY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}") + +# Захват ключа. Параллельный INSERT ждёт коммита первого; просроченный ключ (старше TTL) перехватывается +_CLAIM_SQL = """ +INSERT INTO idempotency_keys AS k (user_id, method, path, idem_key, request_hash, created_at) +VALUES ($1, 'POST', $2, $3, $4, now()) +ON CONFLICT (user_id, method, path, idem_key) DO UPDATE + SET request_hash = EXCLUDED.request_hash, message_id = NULL, created_at = EXCLUDED.created_at + WHERE k.created_at < now() - make_interval(secs => $5) +RETURNING 1 +""" + + +class StrictRequest(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + +class CreateChatRequest(StrictRequest): + title: str + member_ids: List[str] = Field(min_length=1, max_length=100) + + +class CreateMessageRequest(StrictRequest): + text: str + + +def _req_id(request: Request) -> str: + return request.state.request_id + + +# курсор: непрозрачная строка, привязанная к ресурсу (scope) +def encode_cursor(scope: str, created_at: datetime, row_id: uuid.UUID) -> str: + raw = json.dumps([scope, iso(created_at), str(row_id)]).encode() + return base64.urlsafe_b64encode(raw).decode() + + +def decode_cursor(cursor: str, scope: str) -> Tuple[datetime, uuid.UUID]: + """ValueError, если курсор повреждён или выдан для другого ресурса.""" + try: + sc, ts, rid = json.loads(base64.urlsafe_b64decode(cursor.encode())) + if sc != scope: + raise ValueError("scope mismatch") + return datetime.fromisoformat(ts), uuid.UUID(rid) + except Exception as exc: + raise ValueError("invalid cursor") from exc + + +def _bad_text(value: str) -> bool: + return not value.strip() or "\x00" in value # NUL нельзя хранить в PostgreSQL text + + +_CHAT_COLUMNS = ( + "c.id, c.title, c.created_at, " + "array(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.position) AS member_ids" +) + + +def chat_dict(row) -> dict: + 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_dict(row) -> dict: + 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 _check_limit(limit: int) -> bool: + return 1 <= limit <= 100 + + +# чаты +@router.post("/chats", status_code=201) +async def create_chat(req: CreateChatRequest, request: Request, user=Depends(current_user)): + req_id = _req_id(request) + if not (1 <= len(req.title) <= 100) or _bad_text(req.title): + return make_error_response(400, "invalid_request", "Invalid title", req_id) + try: + members = [uuid.UUID(m) for m in req.member_ids] + except ValueError: + return make_error_response(400, "invalid_request", "Invalid member id", req_id) + if len(members) != len(set(members)): + return make_error_response(400, "invalid_request", "Duplicate members found", req_id) + if user["id"] not in members: + return make_error_response(400, "invalid_request", "Caller must be in member_ids", req_id) + + chat_id = uuid.uuid4() + try: + async with request.app.state.pool.acquire() as conn: + # Чат и все участники - одна транзакция: неизвестный участник откатывает всё. + async with conn.transaction(): + created_at = await conn.fetchval( + "INSERT INTO chats (id, title, created_at) VALUES ($1, $2, clock_timestamp()) RETURNING created_at", + chat_id, req.title, + ) + await conn.execute( + "INSERT INTO chat_members (chat_id, user_id, position) " + "SELECT $1, t.u, (t.p - 1)::smallint FROM unnest($2::uuid[]) WITH ORDINALITY AS t(u, p)", + chat_id, members, + ) + except asyncpg.ForeignKeyViolationError: + return make_error_response(400, "invalid_request", "Unknown member", req_id) + + return {"id": str(chat_id), "title": req.title, "member_ids": [str(m) for m in members], + "created_at": iso(created_at)} + + +@router.get("/chats") +async def list_chats(request: Request, limit: int = 50, + cursor: Optional[str] = Query(default=None, min_length=1, max_length=512), + user=Depends(current_user)): + req_id = _req_id(request) + if not _check_limit(limit): + return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id) + scope = "chats:" + str(user["id"]) + base = (f"SELECT {_CHAT_COLUMNS} FROM chats c " + "JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1 ") + if cursor is None: + rows = await request.app.state.pool.fetch( + base + "ORDER BY c.created_at, c.id LIMIT $2", user["id"], limit + 1) + else: + try: + ts, rid = decode_cursor(cursor, scope) + except ValueError: + return make_error_response(400, "invalid_request", "Invalid cursor", req_id) + rows = await request.app.state.pool.fetch( + base + "WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid) " + "ORDER BY c.created_at, c.id LIMIT $4", + user["id"], ts, rid, limit + 1) + items = rows[:limit] + next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None + return {"items": [chat_dict(r) for r in items], "next_cursor": next_cursor} + + +@router.get("/chats/{chat_id}") +async def get_chat(chat_id: uuid.UUID, request: Request, user=Depends(current_user)): + row = await request.app.state.pool.fetchrow( + f"SELECT {_CHAT_COLUMNS} FROM chats c WHERE c.id = $1 " + "AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2)", + chat_id, user["id"], + ) + if row is None: + return make_error_response(404, "not_found", "Chat not found", _req_id(request)) + return chat_dict(row) + + +# сообщения +@router.post("/chats/{chat_id}/messages", status_code=201) +async def send_message(chat_id: uuid.UUID, req: CreateMessageRequest, request: Request, + user=Depends(current_user)): + req_id = _req_id(request) + key = request.headers.get("Idempotency-Key") + if key is None or not IDEMPOTENCY_KEY_RE.fullmatch(key): + return make_error_response(400, "invalid_request", "Missing or invalid Idempotency-Key", req_id) + if _bad_text(req.text): + return make_error_response(400, "invalid_request", "Empty message text", req_id) + if len(req.text) > 4000: + return make_error_response(400, "invalid_request", "Message text exceeds 4000 characters", req_id) + + path = f"/api/v1/chats/{chat_id}/messages" + request_hash = hashlib.sha256( + json.dumps({"text": req.text}, sort_keys=True, ensure_ascii=False).encode()).digest() + + # Захват ключа, вставка сообщения и привязка результата - одна транзакция: + # при сбое откатывается всё, и ключ не фиксирует неудачный результат. + async with request.app.state.pool.acquire() as conn: + async with conn.transaction(): + # Повтор тоже проверяет доступ. + member = await conn.fetchval( + "SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user["id"]) + if not member: + return make_error_response(404, "not_found", "Chat not found", req_id) + + claimed = await conn.fetchval( + _CLAIM_SQL, user["id"], path, key, request_hash, float(config.IDEMPOTENCY_TTL_SECONDS)) + if claimed is None: # ключ уже использован: повтор или конфликт + saved = await conn.fetchrow( + "SELECT request_hash, message_id FROM idempotency_keys " + "WHERE user_id = $1 AND method = 'POST' AND path = $2 AND idem_key = $3", + user["id"], path, key) + if saved["request_hash"] != request_hash: + return make_error_response(409, "conflict", "Idempotency-Key reused with another body", req_id) + row = await conn.fetchrow( + "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE id = $1", + saved["message_id"]) + return message_dict(row) + + row = await conn.fetchrow( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at) " + "VALUES ($1, $2, $3, $4, clock_timestamp()) " + "RETURNING id, chat_id, sender_id, text, created_at", + uuid.uuid4(), chat_id, user["id"], req.text) + await conn.execute( + "UPDATE idempotency_keys SET message_id = $1 " + "WHERE user_id = $2 AND method = 'POST' AND path = $3 AND idem_key = $4", + row["id"], user["id"], path, key) + return message_dict(row) + + +@router.get("/chats/{chat_id}/messages") +async def get_messages(chat_id: uuid.UUID, request: Request, limit: int = 50, + cursor: Optional[str] = Query(default=None, min_length=1, max_length=512), + user=Depends(current_user)): + req_id = _req_id(request) + if not _check_limit(limit): + return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id) + pool = request.app.state.pool + is_member = await pool.fetchval( + "SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user["id"]) + if not is_member: + return make_error_response(404, "not_found", "Chat not found", req_id) + + scope = "msgs:" + str(chat_id) + base = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 " + if cursor is None: + rows = await pool.fetch(base + "ORDER BY created_at, id LIMIT $2", chat_id, limit + 1) + else: + try: + ts, rid = decode_cursor(cursor, scope) + except ValueError: + return make_error_response(400, "invalid_request", "Invalid cursor", req_id) + rows = await pool.fetch( + base + "AND (created_at, id) > ($2::timestamptz, $3::uuid) ORDER BY created_at, id LIMIT $4", + chat_id, ts, rid, limit + 1) + items = rows[:limit] + next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None + return {"items": [message_dict(r) for r in items], "next_cursor": next_cursor} \ No newline at end of file diff --git a/src/common.py b/src/common.py new file mode 100644 index 00000000..ee8e73ad --- /dev/null +++ b/src/common.py @@ -0,0 +1,30 @@ +from datetime import datetime, timezone +from typing import Optional + +from fastapi.responses import JSONResponse +from . import config + + +def iso(dt: datetime) -> str: + """RFC 3339 UTC с Z; микросекунды нужны, чтобы курсор был точным.""" + return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def make_error_response(status_code: int, code: str, message: str, req_id: str, headers: Optional[dict] = None): + h = {"X-Request-Id": req_id, "X-Instance-Id": config.INSTANCE_ID} + if headers: + h.update(headers) + return JSONResponse( + status_code=status_code, + content={"error": {"code": code, "message": message, "request_id": req_id}}, + headers=h, + ) + + +def user_dict(row) -> dict: + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": iso(row["created_at"]), + } \ No newline at end of file diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..521c0342 --- /dev/null +++ b/src/config.py @@ -0,0 +1,29 @@ +import os +import socket +from pathlib import Path + + +def _read_secret(file_var: str, direct_var: str) -> str: + """Секрет из файла (DATABASE_URL_FILE), с запасным вариантом из переменной окружения.""" + path = os.environ.get(file_var) + if path: + return Path(path).read_text().strip() + return os.environ.get(direct_var, "") + + +DATABASE_URL = _read_secret("DATABASE_URL_FILE", "DATABASE_URL") +SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + +DB_POOL_MIN = int(os.environ.get("DB_POOL_MIN", "2")) +DB_POOL_MAX = int(os.environ.get("DB_POOL_MAX", "10")) +DB_CONNECT_TIMEOUT = float(os.environ.get("DB_CONNECT_TIMEOUT", "5")) +DB_COMMAND_TIMEOUT = float(os.environ.get("DB_COMMAND_TIMEOUT", "5")) + +MIGRATIONS_DIR = Path(os.environ.get("MIGRATIONS_DIR", Path(__file__).resolve().parent.parent / "migrations")) +CACHE_URL = _read_secret("CACHE_URL_FILE", "CACHE_URL") +CACHE_TTL_SECONDS = int(os.environ.get("CACHE_TTL_SECONDS", "60")) +CACHE_TIMEOUT = float(os.environ.get("CACHE_TIMEOUT", "0.5")) + +# Идентификатор реплики: hostname контейнера = короткий ID контейнера (по нему stop-one.sh находит контейнер) +INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname() +IDEMPOTENCY_TTL_SECONDS = int(os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400")) \ No newline at end of file diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..d7292bdc --- /dev/null +++ b/src/db.py @@ -0,0 +1,56 @@ +import asyncio +import logging + +import asyncpg + +from . import config + +logger = logging.getLogger("messenger") + +# Произвольный константный ключ: один экземпляр выполняет миграции, остальные ждут. +MIGRATION_LOCK_KEY = 727_001 + + +async def create_pool() -> asyncpg.Pool: + # Пул ограничен по размеру; у соединений и команд есть таймауты. + return await asyncpg.create_pool( + dsn=config.DATABASE_URL, + min_size=config.DB_POOL_MIN, + max_size=config.DB_POOL_MAX, + timeout=config.DB_CONNECT_TIMEOUT, + command_timeout=config.DB_COMMAND_TIMEOUT, + ) + + +async def create_pool_with_retry(attempts: int = 30, delay: float = 1.0) -> asyncpg.Pool: + # БД в compose может подняться позже API. + for attempt in range(1, attempts + 1): + try: + return await create_pool() + except (OSError, asyncpg.PostgresError, asyncio.TimeoutError) as exc: + logger.warning("DB not ready (%d/%d): %s", attempt, attempts, type(exc).__name__) + await asyncio.sleep(delay) + raise RuntimeError("database is unavailable") + + +async def run_migrations(pool: asyncpg.Pool) -> None: + # Применяет migrations/*.sql по порядку имён, каждую один раз. + files = sorted(config.MIGRATIONS_DIR.glob("*.sql")) + async with pool.acquire() as conn: + await conn.execute("SELECT pg_advisory_lock($1)", MIGRATION_LOCK_KEY) + try: + await conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + " version text PRIMARY KEY," + " applied_at timestamptz NOT NULL DEFAULT now())" + ) + applied = {r["version"] for r in await conn.fetch("SELECT version FROM schema_migrations")} + for path in files: + if path.name in applied: + continue + async with conn.transaction(): + await conn.execute(path.read_text()) + await conn.execute("INSERT INTO schema_migrations (version) VALUES ($1)", path.name) + logger.info("Applied migration %s", path.name) + finally: + await conn.execute("SELECT pg_advisory_unlock($1)", MIGRATION_LOCK_KEY) \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..deb01747 --- /dev/null +++ b/src/main.py @@ -0,0 +1,187 @@ +import asyncio +import logging +import re +import sys +import uuid +from contextlib import asynccontextmanager + +import asyncpg +from fastapi import Depends, FastAPI, Request, Response +from fastapi.exceptions import RequestValidationError +from pydantic import BaseModel, ConfigDict +from starlette.exceptions import HTTPException + +from . import config +from .auth import (BASIC_CHALLENGE, current_user, hash_password, new_token, + parse_basic, token_hash, verify_password) +from .chats import router as chats_router +from .common import iso, make_error_response, user_dict +from .db import create_pool_with_retry +from .cache import SessionCache + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] [req_id=%(request_id)s] %(message)s", + handlers=[logging.StreamHandler(sys.stdout)], +) + + +class RequestIdFilter(logging.Filter): + def filter(self, record): + if not hasattr(record, "request_id"): + record.request_id = "-" + return True + + +logger = logging.getLogger("messenger") +logger.addFilter(RequestIdFilter()) + +is_shutting_down = False +USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}") + + +@asynccontextmanager +async def lifespan(app: FastAPI): + app.state.pool = await create_pool_with_retry() + app.state.cache = SessionCache(config.CACHE_URL) + yield + global is_shutting_down + is_shutting_down = True + await app.state.cache.close() + await app.state.pool.close() + logger.info("Application shutdown complete") + + +app = FastAPI(title="MTUSI Messenger - Lab 2", lifespan=lifespan) +app.include_router(chats_router, prefix="/api/v1") + + +@app.middleware("http") +async def middleware_pipeline(request: Request, call_next): + req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4()) + request.state.request_id = req_id + if is_shutting_down and request.url.path != "/health/live": + return make_error_response(503, "unavailable", "Server is shutting down", req_id) + logger.info(f"Incoming request {request.method} {request.url.path}", extra={"request_id": req_id}) + response: Response = await call_next(request) + response.headers["X-Request-Id"] = req_id + response.headers["X-Instance-Id"] = config.INSTANCE_ID + logger.info(f"Completed {request.method} {request.url.path} with status {response.status_code}", + extra={"request_id": req_id}) + return response + + +def _req_id(request: Request) -> str: + return getattr(request.state, "request_id", str(uuid.uuid4())) + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + return make_error_response(400, "invalid_request", "Validation error", _req_id(request)) + + +@app.exception_handler(HTTPException) +async def http_exception_handler(request: Request, exc: HTTPException): + code = { + 400: "invalid_request", 401: "unauthorized", 404: "not_found", 409: "conflict", + 413: "payload_too_large", 415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable", + }.get(exc.status_code, "internal_error" if exc.status_code >= 500 else "invalid_request") + return make_error_response(exc.status_code, code, "Request failed", _req_id(request), exc.headers) + + +async def dependency_unavailable_handler(request: Request, exc: Exception): + """БД недоступна или не ответила в срок: ограниченная 503, без деталей и без доверия анониму.""" + logger.error("Dependency failure: %s", type(exc).__name__, extra={"request_id": _req_id(request)}) + return make_error_response(503, "unavailable", "Service temporarily unavailable", _req_id(request)) + + +for _exc in (asyncpg.PostgresError, asyncpg.InterfaceError, OSError, asyncio.TimeoutError): + app.add_exception_handler(_exc, dependency_unavailable_handler) + + +@app.exception_handler(Exception) +async def generic_exception_handler(request: Request, exc: Exception): + logger.error("Unhandled exception: %s", type(exc).__name__, extra={"request_id": _req_id(request)}) + return make_error_response(500, "internal_error", "Internal server error", _req_id(request)) + + +class StrictRequest(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + +class CreateUserRequest(StrictRequest): + username: str + display_name: str + password: str + + +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +async def health_ready(request: Request): + # Критичная зависимость для готовности - PostgreSQL. + await request.app.state.pool.fetchval("SELECT 1", timeout=2) + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +async def register_user(req: CreateUserRequest, request: Request): + req_id = _req_id(request) + if not USERNAME_RE.fullmatch(req.username): + return make_error_response(400, "invalid_request", "Invalid username format", req_id) + if not (1 <= len(req.display_name) <= 100) or not req.display_name.strip() or "\x00" in req.display_name: + return make_error_response(400, "invalid_request", "Invalid display_name", req_id) + if not (12 <= len(req.password) <= 128): + return make_error_response(400, "invalid_request", "Invalid password length", req_id) + + pw_hash = await hash_password(req.password) + try: + row = await request.app.state.pool.fetchrow( + "INSERT INTO users (id, username, display_name, password_hash, created_at) " + "VALUES ($1, $2, $3, $4, clock_timestamp()) " + "RETURNING id, username, display_name, created_at", + uuid.uuid4(), req.username, req.display_name, pw_hash, + ) + except asyncpg.UniqueViolationError: # гонку одинаковых username решает UNIQUE, а не SELECT + return make_error_response(409, "conflict", "Username already exists", req_id) + return user_dict(row) + +@app.get("/api/v1/users/me") +async def get_current_user(user=Depends(current_user)): + return user_dict(user) + + +@app.post("/api/v1/auth/sessions", status_code=201) +async def create_session(request: Request): + req_id = _req_id(request) + creds = parse_basic(request.headers.get("Authorization")) + if creds is None: + return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE) + username, password = creds + pool = request.app.state.pool + row = await pool.fetchrow( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1", username + ) + ok = await verify_password(row["password_hash"] if row else None, password) + if row is None or not ok: + return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE) + + token = new_token() + expires_at = await pool.fetchval( + "INSERT INTO sessions (token_hash, user_id, created_at, expires_at) " + "VALUES ($1, $2, now(), now() + make_interval(secs => $3)) RETURNING expires_at", + token_hash(token), row["id"], float(config.SESSION_TTL_SECONDS), + ) + return {"token": token, "token_type": "Bearer", "expires_at": iso(expires_at), "user": user_dict(row)} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def logout(request: Request, user=Depends(current_user)): + await request.app.state.pool.execute( + "UPDATE sessions SET revoked_at = now() WHERE token_hash = $1", request.state.token_hash + ) + await request.app.state.cache.delete(request.state.token_hash) + return Response(status_code=204) \ No newline at end of file diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..52541c51 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,19 @@ +import asyncio +import logging +import sys + +from .db import create_pool_with_retry, run_migrations + +logging.basicConfig(level=logging.INFO, stream=sys.stdout) + + +async def main() -> None: + pool = await create_pool_with_retry() + try: + await run_migrations(pool) + finally: + await pool.close() + + +if __name__ == "__main__": + asyncio.run(main()) \ No newline at end of file diff --git a/student_tests/test_lab2.py b/student_tests/test_lab2.py new file mode 100644 index 00000000..37dd02fc --- /dev/null +++ b/student_tests/test_lab2.py @@ -0,0 +1,585 @@ +#!/usr/bin/env python3 + +import concurrent.futures +import json +import os +import sys +import uuid +import urllib.error +import urllib.parse +import urllib.request +from datetime import datetime +import base64 + +BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/") +PASSWORD = "correct-horse-battery" + + +def request(method, path, expected, body=None, headers=None, raw_body=None): + url = BASE_URL + path + + request_headers = dict(headers or {}) + + if raw_body is not None: + data = raw_body + elif body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + else: + data = None + + if body is not None or raw_body is not None: + request_headers.setdefault("Content-Type", "application/json") + + req = urllib.request.Request( + url, + data=data, + method=method, + headers=request_headers, + ) + + try: + with urllib.request.urlopen(req, timeout=10) as response: + status = response.status + response_headers = response.headers + response_body = response.read() + + except urllib.error.HTTPError as exc: + status = exc.code + response_headers = exc.headers + response_body = exc.read() + + if status != expected: + raise AssertionError( + f"{method} {path}: expected HTTP {expected}, got {status}. " + f"Body={response_body!r}" + ) + + request_id = response_headers.get("X-Request-Id") + if not request_id: + raise AssertionError( + f"{method} {path}: missing X-Request-Id" + ) + + parsed = None + + if response_body: + content_type = response_headers.get_content_type() + + if content_type == "application/json": + parsed = json.loads(response_body.decode("utf-8")) + + if status >= 400: + 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", + } + if not isinstance(parsed, dict) or set(parsed) != {"error"}: + raise AssertionError(f"Invalid error response: {parsed!r}") + error = parsed["error"] + if not isinstance(error, dict) or set(error) != {"code", "message", "request_id"}: + raise AssertionError(f"Invalid error fields: {error!r}") + if error["code"] != codes[status] or error["request_id"] != request_id: + raise AssertionError(f"Wrong error code or request ID: {error!r}") + if not isinstance(error["message"], str) or not error["message"].strip(): + raise AssertionError("Error message must be a nonempty string") + + return { + "status": status, + "headers": response_headers, + "json": parsed, + "bytes": response_body, + } + + +def unique_username(prefix): + # username должен соответствовать [a-z0-9_]{3,32} + suffix = uuid.uuid4().hex[:12] + return f"{prefix}_{suffix}" + + +def basic(username, password=PASSWORD): + raw = f"{username}:{password}".encode("utf-8") + return "Basic " + base64.b64encode(raw).decode() + + +def create_user(prefix="usr", login=True): + user = request("POST", "/api/v1/users", 201, body={ + "username": unique_username(prefix), + "display_name": f"Test {prefix}", + "password": PASSWORD, + })["json"] + if login: + session = request("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": basic(user["username"])})["json"] + user["token"] = session["token"] + return user + + +def auth(user): + return {"Authorization": "Bearer " + user["token"]} + + +def create_chat(owner, members, title="Student test chat"): + result = request( + "POST", + "/api/v1/chats", + 201, + headers=auth(owner), + body={ + "title": title, + "member_ids": [u["id"] for u in members], + }, + ) + + return result["json"] + + +def create_message(user, chat, text): + return request( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 201, + headers=auth(user), + body={"text": text}, + )["json"] + + +def test_malformed_json(): + for body in (b'{"username": "broken",', b"\xff"): + request("POST", "/api/v1/users", 400, raw_body=body) + + print("PASS malformed JSON and invalid UTF-8 -> 400 with error envelope") + + +def test_duplicate_username(): + username = unique_username("dup") + + body = { + "username": username, + "display_name": "First", + "password": PASSWORD, + } + + request( + "POST", + "/api/v1/users", + 201, + body=body, + ) + + request( + "POST", + "/api/v1/users", + 409, + body={ + "username": username, + "display_name": "Second", + "password": PASSWORD, + }, + ) + + print("PASS duplicate username -> 409") + + +def test_outsider_chat(): + alice = create_user("alice") + bob = create_user("bob") + eve = create_user("eve") + + chat = create_chat( + alice, + [alice, bob], + "Private chat", + ) + + request( + "GET", + f"/api/v1/chats/{chat['id']}", + 404, + headers=auth(eve), + ) + + request( + "GET", + f"/api/v1/chats/{chat['id']}/messages", + 404, + headers=auth(eve), + ) + + request( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 404, + headers=auth(eve), + body={"text": "Not allowed"}, + ) + page = request("GET", "/api/v1/chats", 200, headers=auth(eve))["json"] + if page != {"items": [], "next_cursor": None}: + raise AssertionError("Outsider can see a private chat in the list") + + print("PASS outsider cannot access chat -> 404") + + +def test_empty_and_whitespace_message(): + alice = create_user("emptya") + bob = create_user("emptyb") + + chat = create_chat( + alice, + [alice, bob], + "Empty message test", + ) + + request( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 400, + headers=auth(alice), + body={"text": ""}, + ) + + request( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 400, + headers=auth(alice), + body={"text": " \t\n"}, + ) + + print("PASS empty/whitespace message -> 400") + + +def test_extra_json_field(): + request( + "POST", + "/api/v1/users", + 400, + body={ + "username": unique_username("extra"), + "display_name": "Extra", + "password": PASSWORD, + "admin": True, + }, + ) + + print("PASS extra JSON field -> 400") + + +def test_multi_page_history(): + alice = create_user("pagea") + bob = create_user("pageb") + + chat = create_chat( + alice, + [alice, bob], + "Pagination test", + ) + + expected = [] + + for i in range(7): + message = create_message( + alice, + chat, + f"pagination-message-{i}", + ) + + expected.append(message) + + expected.sort( + key=lambda message: ( + datetime.fromisoformat( + message["created_at"].replace("Z", "+00:00") + ), + uuid.UUID(message["id"]).int, + ) + ) + + expected_ids = [ + message["id"] + for message in expected + ] + + collected = [] + cursor = None + + for _ in range(len(expected) + 1): + path = ( + f"/api/v1/chats/{chat['id']}/messages" + f"?limit=2" + ) + + if cursor is not None: + path += "&cursor=" + urllib.parse.quote( + cursor, + safe="", + ) + + page = request( + "GET", + path, + 200, + headers=auth(bob), + )["json"] + + ids = [item["id"] for item in page["items"]] + collected.extend(ids) + + cursor = page["next_cursor"] + + if cursor is None: + break + else: + raise AssertionError("Pagination did not reach the last page") + + if collected != expected_ids: + raise AssertionError( + "Pagination lost, duplicated or reordered messages.\n" + f"Expected: {expected_ids}\n" + f"Received: {collected}" + ) + + if len(collected) != len(set(collected)): + raise AssertionError( + "Pagination returned duplicate messages" + ) + + print( + f"PASS pagination: {len(collected)} messages " + "read through multiple pages" + ) + + +def test_concurrent_100_messages(): + users = [ + create_user(f"c{i}") + for i in range(10) + ] + + chat = create_chat( + users[0], + users, + "Concurrency test", + ) + + def worker(client_index): + sent = [] + + for message_index in range(10): + text = ( + f"client-{client_index}-" + f"message-{message_index}" + ) + + result = create_message( + users[client_index], + chat, + text, + ) + + sent.append(result) + + return sent + + all_sent = [] + + with concurrent.futures.ThreadPoolExecutor( + max_workers=10 + ) as executor: + futures = [ + executor.submit(worker, i) + for i in range(10) + ] + + for future in concurrent.futures.as_completed( + futures + ): + all_sent.extend(future.result()) + + if len(all_sent) != 100: + raise AssertionError( + f"Expected 100 successful POSTs, got {len(all_sent)}" + ) + + page = request( + "GET", + f"/api/v1/chats/{chat['id']}/messages?limit=100", + 200, + headers=auth(users[0]), + )["json"] + + messages = page["items"] + + if len(messages) != 100: + raise AssertionError( + f"Expected exactly 100 stored messages, " + f"got {len(messages)}" + ) + + ids = [message["id"] for message in messages] + + if len(set(ids)) != 100: + raise AssertionError( + "Expected 100 unique message IDs" + ) + + if set(ids) != {message["id"] for message in all_sent}: + raise AssertionError("Stored messages differ from successful POST responses") + + texts = [message["text"] for message in messages] + + if len(set(texts)) != 100: + raise AssertionError( + "Expected 100 unique message texts" + ) + + if page["next_cursor"] is not None: + raise AssertionError( + "100 messages with limit=100 should fit in one page" + ) + + print( + "PASS concurrency: 10 clients sent 100 messages; " + "exactly 100 unique messages stored" + ) + + +def test_invalid_chat_ids(): + user = create_user("uuid") + for chat_id, expected in (("not-a-uuid", 400), (str(uuid.uuid4()), 404)): + path = f"/api/v1/chats/{chat_id}" + request("GET", path, expected, headers=auth(user)) + request("GET", path + "/messages", expected, headers=auth(user)) + request("POST", path + "/messages", expected, + headers=auth(user), body={"text": "Test"}) + print("PASS invalid chat UUID -> 400; unknown valid UUID -> 404") + + +def test_chat_member_limits(): + users = [create_user("member", login=(i == 0)) for i in range(101)] + owner = users[0] + for members in ([], users, [owner, owner], users[1:3]): + request("POST", "/api/v1/chats", 400, headers=auth(owner), body={ + "title": "Invalid members", "member_ids": [user["id"] for user in members], + }) + request("POST", "/api/v1/chats", 400, headers=auth(owner), body={ + "title": "Unknown member", "member_ids": [owner["id"], str(uuid.uuid4())], + }) + chat = create_chat(owner, users[:100]) + if len(chat["member_ids"]) != 100: + raise AssertionError("Chat must accept exactly 100 members") + print("PASS chat members: 1..100, unique, existing, caller included") + + +def test_invalid_pagination(): + user = create_user("cursor") + chat = create_chat(user, [user]) + other_chat = create_chat(user, [user]) + other_message = create_message(user, other_chat, "Other history") + paths = ("/api/v1/chats", f"/api/v1/chats/{chat['id']}/messages") + for path in paths: + for query in ("cursor=", "cursor=unknown", "limit=0", "limit=101", "limit=abc", "limit=1.5"): + request("GET", path + "?" + query, 400, headers=auth(user)) + request("GET", paths[1] + "?cursor=" + other_message["id"], 400, headers=auth(user)) + print("PASS invalid cursor/limit and cursor from another chat -> 400") + + +def test_multi_page_chats(): + user = create_user("chatpage") + chats = [create_chat(user, [user], f"Chat {i}") for i in range(7)] + chats.sort(key=lambda chat: (chat["created_at"], uuid.UUID(chat["id"]).int)) + collected = [] + cursor = None + for page_number in range(len(chats) + 1): + query = {"limit": 2 if page_number == 0 else 3} + if cursor is not None: + query["cursor"] = cursor + page = request("GET", "/api/v1/chats?" + urllib.parse.urlencode(query), + 200, headers=auth(user))["json"] + collected.extend(chat["id"] for chat in page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + else: + raise AssertionError("Chat pagination did not reach the last page") + if collected != [chat["id"] for chat in chats]: + raise AssertionError("Chat pagination lost, duplicated or reordered chats") + print("PASS pagination: 7 chats, changing limit between pages") + + +def test_validation_and_unicode(): + for display_name in ("", " \t", "x" * 101, 123, None): + request("POST", "/api/v1/users", 400, body={ + "username": unique_username("invalid"), "display_name": display_name, "password": PASSWORD, + }) + request("POST", "/api/v1/users", 400, + body={"username": True, "display_name": "Test", "password": PASSWORD}) + for password in ("short", "x" * 129, 12345678901234, None): + request("POST", "/api/v1/users", 400, body={ + "username": unique_username("badpw"), "display_name": "Test", "password": password, + }) + request("POST", "/api/v1/users", 400, + body={"username": unique_username("nopw"), "display_name": "Test"}) + + unicode_password = "\U00020000" * 12 # пароль не из ASCII проходит через Basic/UTF-8 и KDF + user = request("POST", "/api/v1/users", 201, body={ + "username": unique_username("unicode"), "display_name": "\U00020000" * 100, + "password": unicode_password, + })["json"] + session = request("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": basic(user["username"], unicode_password)})["json"] + user["token"] = session["token"] + + chat = create_chat(user, [user]) + path = f"/api/v1/chats/{chat['id']}/messages" + text = "\U00020000" * 4000 + message = create_message(user, chat, text) + if message["text"] != text: + raise AssertionError("Unicode message was altered") + for invalid in (text + "x", 123, None): + request("POST", path, 400, headers=auth(user), body={"text": invalid}) + + request("GET", "/api/v1/users/me", 401) + request("GET", "/api/v1/users/me", 401, headers={"X-User-Id": user["id"]}) + request("GET", "/api/v1/users/me", 401, + headers={"Authorization": basic(user["username"], unicode_password)}) + print("PASS strict types, Unicode, password rules, Bearer-only identification") + + +def main(): + tests = [ + test_malformed_json, + test_duplicate_username, + test_outsider_chat, + test_empty_and_whitespace_message, + test_extra_json_field, + test_multi_page_history, + test_concurrent_100_messages, + test_invalid_chat_ids, + test_chat_member_limits, + test_invalid_pagination, + test_multi_page_chats, + test_validation_and_unicode, + ] + + print(f"Testing {BASE_URL}") + + for test in tests: + test() + + print() + print( + f"PASS: {len(tests)} student test scenarios completed" + ) + + +if __name__ == "__main__": + try: + main() + except Exception as exc: + print( + f"FAIL: {type(exc).__name__}: {exc}", + file=sys.stderr, + ) + sys.exit(1) diff --git a/student_tests/test_level4.py b/student_tests/test_level4.py new file mode 100644 index 00000000..d523e36b --- /dev/null +++ b/student_tests/test_level4.py @@ -0,0 +1,195 @@ +"""Проверки уровня 4. Нужен запущенный стенд (docker compose up -d --build). +Тесты отказов сами останавливают и запускают valkey/postgres/api, volumes не удаляются. +Запуск: python3 -m unittest discover -s student_tests -p "test_level4.py" -v +""" +import base64 +import json +import os +import subprocess +import threading +import time +import unittest +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +BASE = os.environ.get("BASE_URL", "http://localhost:8080") +ROOT = Path(__file__).resolve().parents[1] +PASSWORD = "correct-horse-battery" + + +def call(method, path, body=None, headers=None): + data = json.dumps(body).encode() if body is not None else None + h = {"Content-Type": "application/json"} if body is not None else {} + h.update(headers or {}) + req = urllib.request.Request(BASE + path, data=data, method=method, headers=h) + try: + with urllib.request.urlopen(req, timeout=15) as resp: + raw = resp.read() + return resp.status, (json.loads(raw) if raw else None) + except urllib.error.HTTPError as exc: + raw = exc.read() + try: + return exc.code, (json.loads(raw) if raw else None) + except ValueError: + return exc.code, None + + +def register(username=None): + username = username or "u" + uuid.uuid4().hex[:12] + status, user = call("POST", "/api/v1/users", + {"username": username, "display_name": "Test", "password": PASSWORD}) + assert status == 201, status + return user + + +def login(username, password=PASSWORD): + basic = base64.b64encode(f"{username}:{password}".encode()).decode() + return call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic}) + + +def bearer(token): + return {"Authorization": "Bearer " + token} + + +def compose(*args, env=None): + full_env = dict(os.environ) + full_env.update(env or {}) + result = subprocess.run(["docker", "compose", "--env-file", ".env", *args], + cwd=ROOT, env=full_env, check=True, capture_output=True, text=True) + return result.stdout + + +def wait_ready(timeout=90): + deadline = time.time() + timeout + while time.time() < deadline: + try: + if call("GET", "/health/ready")[0] == 200: + return + except OSError: + pass + time.sleep(1) + raise AssertionError("API did not become ready") + + +def new_session(): + user = register() + status, session = login(user["username"]) + assert status == 201 + return user, session["token"] + + +class Level4(unittest.TestCase): + @classmethod + def setUpClass(cls): + wait_ready() + + def test_wrong_password(self): + user = register() + status, body = login(user["username"], "definitely-wrong-password") + self.assertEqual(status, 401) + self.assertEqual(body["error"]["code"], "unauthorized") + status, _ = login("no_such_user_" + uuid.uuid4().hex[:8]) + self.assertEqual(status, 401) + + def test_logout_revokes_session_and_cache(self): + _, token = new_session() + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) # прогрев кэша + self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", headers=bearer(token))[0], 204) + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 401) + self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", headers=bearer(token))[0], 401) + + def test_x_user_id_gives_no_access(self): + user = register() + status, _ = call("GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]}) + self.assertEqual(status, 401) + + def test_register_race_same_username(self): + username = "race" + uuid.uuid4().hex[:10] + results = [] + + def worker(): + status, _ = call("POST", "/api/v1/users", + {"username": username, "display_name": "Race", "password": PASSWORD}) + results.append(status) + + threads = [threading.Thread(target=worker) for _ in range(10)] + for t in threads: + t.start() + for t in threads: + t.join() + self.assertEqual(results.count(201), 1, results) + self.assertEqual(results.count(409), 9, results) + + def test_chat_creation_rolls_back(self): + user, token = new_session() + title = "rollback-" + uuid.uuid4().hex + status, _ = call("POST", "/api/v1/chats", + {"title": title, "member_ids": [user["id"], str(uuid.uuid4())]}, + headers=bearer(token)) + self.assertEqual(status, 400) + # Проверяем саму БД: после отката не осталось ни чата, ни участников. + count = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", + "-tAc", f"SELECT count(*) FROM chats WHERE title = '{title}'").strip() + self.assertEqual(count, "0") + + def test_valkey_down_falls_back_to_postgres(self): + user, token = new_session() + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + compose("stop", "valkey") + try: + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + self.assertEqual(login(user["username"])[0], 201) + self.assertEqual(call("GET", "/api/v1/users/me")[0], 401) + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer("x" * 43))[0], 401) + finally: + compose("start", "valkey") + + def test_valkey_flush_keeps_sessions(self): + _, token = new_session() + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + compose("exec", "-T", "valkey", "valkey-cli", "FLUSHALL") + # кэш пуст, но сессия живёт в PostgreSQL; ответ не зависит от состояния кэша + deadline = time.time() + 10 + refilled = False + while time.time() < deadline: + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + keys = compose("exec", "-T", "valkey", "valkey-cli", "keys", "sess:*") + if keys.strip(): + refilled = True + break + time.sleep(1) + self.assertTrue(refilled, "cache should be refilled after a miss") + + def test_postgres_down_returns_bounded_error(self): + compose("stop", "postgres") + try: + status, body = call("GET", "/health/ready") + self.assertEqual(status, 503) + self.assertEqual(body["error"]["code"], "unavailable") + # неизвестный токен нельзя ни подтвердить, ни отвергнуть без БД: 503, не 200 + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer("y" * 43))[0], 503) + self.assertEqual(call("GET", "/api/v1/users/me")[0], 401) # аноним не доверенный + self.assertEqual(call("POST", "/api/v1/users", + {"username": "down" + uuid.uuid4().hex[:8], "display_name": "X", + "password": PASSWORD})[0], 503) + finally: + compose("start", "postgres") + wait_ready() + + def test_zz_session_expiry(self): + compose("up", "-d", "api", env={"SESSION_TTL_SECONDS": "2"}) + try: + wait_ready() + _, token = new_session() + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + time.sleep(3.5) + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 401) + finally: + compose("up", "-d", "api") # обратно к TTL из .env + wait_ready() + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/student_tests/test_lifecycle.py b/student_tests/test_lifecycle.py new file mode 100644 index 00000000..5b87eff8 --- /dev/null +++ b/student_tests/test_lifecycle.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +"""Жизненный цикл ЛР 2: данные и сессии переживают перезапуск всего стенда (API, PostgreSQL, Valkey). +Нужен запущенный compose-стенд; перезапуск делает scripts/restart.sh (volumes сохраняются).""" +import os +import sys +import uuid + +import test_lab2 as api +from test_sigterm import ROOT, run, wait_ready + + +def compose_logs(): + return run("docker", "compose", "--project-directory", str(ROOT), "--env-file", str(ROOT / ".env"), + "logs", "api", "--no-color").stdout + + +def main(): + api.BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/") + wait_ready(api.BASE_URL) + + alice = api.create_user("lifealice") + bob = api.create_user("lifebob") + outsider = api.create_user("lifeoutsider") + chat = api.create_chat(alice, [alice, bob], "Lifecycle test") + texts = ["private-lifecycle-" + uuid.uuid4().hex for _ in range(2)] + sent = [api.create_message(user, chat, text) for user, text in zip((alice, bob), texts)] + path = f"/api/v1/chats/{chat['id']}/messages" + page = api.request("GET", path, 200, headers=api.auth(bob))["json"] + if [m["id"] for m in page["items"]] != [m["id"] for m in sent]: + raise AssertionError("Created messages are missing or reordered") + print("PASS two users created and read two messages: HTTP 201, then HTTP 200") + + api.request("GET", path, 404, headers=api.auth(outsider)) + api.request("POST", path, 404, headers=api.auth(outsider), body={"text": "Forbidden"}) + print("PASS third user cannot read or write the chat: HTTP 404") + + logs = compose_logs() + if any(text in logs for text in texts): + raise AssertionError("Message contents leaked into container logs") + if "req_id=" not in logs or "with status 201" not in logs: + raise AssertionError("Request logs are missing") + print("PASS request logs include IDs and statuses, without message contents") + + print("Command: scripts/restart.sh (API + PostgreSQL + Valkey, volumes kept)", flush=True) + run(str(ROOT / "scripts" / "restart.sh"), timeout=120) + wait_ready(api.BASE_URL, timeout=90) + + # те же токены, те же данные + api.request("GET", "/api/v1/users/me", 200, headers=api.auth(alice)) + after = api.request("GET", path, 200, headers=api.auth(bob))["json"] + if after["items"] != page["items"]: + raise AssertionError("History changed after restart") + api.request("GET", path, 404, headers=api.auth(outsider)) + print("PASS after restart: same tokens read the same history") + + api.request("DELETE", "/api/v1/auth/sessions/current", 204, headers=api.auth(alice)) + api.request("GET", path, 401, headers=api.auth(alice)) + api.request("GET", path, 200, headers=api.auth(bob)) + print("PASS logout revokes only alice's session; bob's session still works") + print("PASS persistent lifecycle: data and sessions survive full restart") + + +if __name__ == "__main__": + try: + main() + except Exception as exc: + print(f"FAIL: {type(exc).__name__}: {exc}", file=sys.stderr) + sys.exit(1) \ No newline at end of file diff --git a/student_tests/test_sigterm.py b/student_tests/test_sigterm.py new file mode 100644 index 00000000..384cfc36 --- /dev/null +++ b/student_tests/test_sigterm.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python3 + +import concurrent.futures +import os +import socket +import subprocess +import sys +import time +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +IMAGE = os.environ.get("IMAGE", "mtusi-messenger:lab2") +NETWORK = os.environ.get("COMPOSE_NETWORK", "mtusi-lab2_default") +PORT = int(os.environ.get("SIGTERM_PORT", "18080")) + + +def run(*args, check=True, timeout=60): + return subprocess.run( + args, check=check, text=True, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, timeout=timeout, + ) + +def docker_run_args(name, port): + # Отдельный контейнер API в сети compose: те же PostgreSQL и Valkey, секрет только для чтения + return ["docker", "run", "-d", "--name", name, "--network", NETWORK, + "-p", f"127.0.0.1:{port}:8080", + "-v", f"{ROOT}/secrets/database_url:/run/secrets/database_url:ro", + "-e", "DATABASE_URL_FILE=/run/secrets/database_url", + "-e", "CACHE_URL=redis://valkey:6379/0", + IMAGE] + + +def wait_ready(base_url, timeout=60): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + with urllib.request.urlopen(base_url + "/health/ready", timeout=1) as response: + if response.status == 200: + return + except (urllib.error.URLError, ConnectionError, TimeoutError): + pass + time.sleep(0.2) + raise RuntimeError("Test container did not become ready") + + +def connection_rejected(base_url): + try: + with urllib.request.urlopen(base_url + "/health/ready", timeout=0.5): + return False + except urllib.error.HTTPError: + return False + except (urllib.error.URLError, ConnectionError, TimeoutError): + return True + + +def test_shutdown(incomplete_request): + name = "mtusi-messenger-sigterm-" + uuid.uuid4().hex[:8] + base_url = f"http://127.0.0.1:{PORT}" + scenario = "incomplete POST" if incomplete_request else "idle" + pending = None + try: + run(*docker_run_args(name, PORT)) + wait_ready(base_url) + + if incomplete_request: + pending = socket.create_connection(("127.0.0.1", PORT), timeout=3) + pending.sendall( + b"POST /api/v1/users HTTP/1.1\r\n" + b"Host: localhost\r\nContent-Type: application/json\r\n" + b"Content-Length: 100\r\nExpect: 100-continue\r\n\r\n" + ) + response = b"" + while b"\r\n\r\n" not in response: + part = pending.recv(1024) + if not part: + raise AssertionError("Connection closed before 100 Continue") + response += part + if b"100 Continue" not in response: + raise AssertionError(f"Expected 100 Continue, received {response!r}") + pending.sendall(b"{") + + print(f"Scenario: {scenario}; docker stop --timeout 10 {name}", flush=True) + start = time.monotonic() + with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor: + stopped = executor.submit(run, "docker", "stop", "--timeout", "10", name) + deadline = start + 2 + while not connection_rejected(base_url): + if time.monotonic() >= deadline: + raise AssertionError("New connections are still accepted during shutdown") + time.sleep(0.05) + rejected_after = time.monotonic() - start + stopped.result(timeout=12) + elapsed = time.monotonic() - start + + exit_code = int(run("docker", "inspect", name, "--format", "{{.State.ExitCode}}").stdout) + if exit_code != 0: + raise AssertionError(f"Container exited with code {exit_code}, expected 0") + if elapsed > 10: + raise AssertionError(f"Shutdown exceeded 10 seconds: {elapsed:.3f}s") + if not connection_rejected(base_url): + raise AssertionError("API still accepts connections after shutdown") + + logs = run("docker", "logs", name).stdout + if "Application shutdown complete" not in logs: + raise AssertionError("Application did not complete its shutdown handler") + print(f"PASS {scenario}: exit code 0; shutdown {elapsed:.3f}s; " + f"new connections rejected after {rejected_after:.3f}s") + finally: + if pending is not None: + pending.close() + run("docker", "rm", "-f", name, check=False) + + +def main(): + print(f"Image: {IMAGE}") + test_shutdown(False) + test_shutdown(True) + print("PASS SIGTERM: both scenarios completed within 10 seconds") + + +if __name__ == "__main__": + try: + main() + except Exception as exc: + print(f"FAIL: {type(exc).__name__}: {exc}", file=sys.stderr) + sys.exit(1)