ЛР 3 - БПИ2302 - Бахаева - На 4 #139

Closed
bakhaeva_liana wants to merge 2 commits from bakhaeva_liana/mtusi2026lab3-fork:main into main
27 changed files with 1700 additions and 28 deletions
+19
View File
@@ -0,0 +1,19 @@
FROM python:3.12-slim
RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ src/
RUN useradd -m appuser
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --retries=3 CMD curl -f http://localhost:8080/health/live || exit 1
CMD ["python", "-m", "uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
+158 -23
View File
@@ -1,37 +1,172 @@
# Отчёт — лабораторная 3
# Отчёт — Лабораторная работа №3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- **Автор, группа:** Бахаева Лиана, БПИ2302
- **Целевая оценка:** 4 (выполнен весь уровень 3 + все пункты уровня 4)
- **Commit/PR:** *(указать после публикации)*
- **Использованные источники, библиотеки и помощь ИИ:**
FastAPI, Uvicorn, asyncpg, argon2-cffi, Pydantic, httpx. Официальная документация Docker Compose, Nginx, PostgreSQL.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Prerequisites:**
- Docker Desktop 24+ (Windows, WSL2 backend)
- Python 3.12+ (для локального запуска тестов)
- Git Bash (на Windows)
## Архитектура и решения
**Версии образов:**
- `postgres:15-alpine`
- `nginx:1.25-alpine`
- `python:3.12-slim` (базовый для API)
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
**Команды для развертывания:**
## Доказательства критериев
```bash
# 1. Клонировать репозиторий
git clone <url>
cd mtusi2026lab3-fork
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
# 2. Создать .env (локальные секреты, не коммитятся)
cat << 'EOF' > .env
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
SESSION_STORE=postgres
DATABASE_URL=postgresql://messenger:lab3password@postgres:5432/messenger
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
EOF
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
# 3. Сборка и запуск
docker compose build --no-cache
docker compose up -d
## Эксперименты и отказы
# 4. Ожидание готовности (~40 секунд)
docker compose ps
# Все сервисы должны быть в статусе healthy/running
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
# 5. Запуск тестов
python tests/smoke.py --base-url http://localhost:8080
# или
make test
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
# 6. Скрипты уровня 4
./scripts/failover-test.sh http://localhost:8080
./scripts/idempotency-concurrent.sh http://localhost:8080
./scripts/rolling-update.sh http://localhost:8080
## Ограничения и следующие шаги
# 7. Безопасная остановка
docker compose down
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
# 8. Удаление учебных данных (полный сброс)
docker compose down -v --remove-orphans
Архитектура и решения
Схема процессов и хранилищ:
text
Клиент :8080
↓
Nginx (round-robin, rate limit 20r/s)
↓ ↓
api1 api2
↓ ↓
└── PostgreSQL (postgres:5432) ──┘
├── users
├── chats
├── chat_members
├── messages
├── sessions
└── idempotency_keys
Источник истины: PostgreSQL. Все данные (пользователи, чаты, сообщения, сессии, ключи идемпотентности) хранятся в БД. API-реплики полностью stateless.
Транзакционные границы: создание чата с участниками — одна транзакция (атомарно); запись сообщения + идемпотентный ключ — раздельно (INSERT + ON CONFLICT DO NOTHING); создание сессии — отдельная транзакция.
Перенос из lab2: модели Pydantic, структура роутеров, базовая логика хеширования паролей.
Добавлено в lab3: Docker Compose, Nginx, health endpoints, идемпотентность, миграции, graceful shutdown, скрипты управления и тестирования отказов.
Конфигурация: все переменные из .env читаются в src/config.py через os.getenv() и используются напрямую в коде (без файловых секретов, что критично для Windows).
Доказательства критериев
Критерий README Команда/Сценарий Наблюдаемый результат Файл доказательства
Публичный smoke python tests/smoke.py Проходит регистрация, логин, создание чата, отправка сообщения tests/smoke.py, логи docker compose logs api1
≥2 API-реплики, одна точка входа docker compose ps 4 сервиса: postgres(healthy), api1(healthy), api2(healthy), nginx(running) compose.yaml, скриншот docker compose ps
Разные запросы — разные реплики curl -I http://localhost:8080/health/live (повторно) Заголовок X-Instance-Id чередуется между api-instance-1 и api-instance-2 src/middleware.py, nginx/nginx.conf
Остановка одной реплики docker compose stop api1 + запросы api2 продолжает обслуживать, данные сохраняются в БД scripts/failover-test.sh
Идемпотентность POST scripts/idempotency-concurrent.sh 10 параллельных запросов с одним ключом → 1 сообщение в БД src/idempotency.py, migrations/001_init.sql
Health/readiness, SIGTERM docker compose logs api1 /health/ready возвращает 200, при SIGTERM пул закрывается src/lifecycle.py, src/routers/health.py
LB исключает недоступный backend docker compose stop api1 Nginx через proxy_next_upstream переключается на api2 nginx/nginx.conf
CPU/RAM-лимиты docker compose ps + inspect Ограничения заданы в deploy.resources.limits compose.yaml
API не публикуют порты наружу docker compose ps Колонка PORTS: 8080/tcp (expose), только nginx: 0.0.0.0:8080->80/tcp compose.yaml
Миграции однократно docker compose logs migrate Статус Exited (0), таблицы созданы compose.yaml (restart: "no")
Rolling update scripts/rolling-update.sh Поочерёдная пересборка api1 → api2 под нагрузкой scripts/rolling-update.sh
Failover с метриками scripts/failover-test.sh Замеры RPS baseline/down/back для каждой реплики scripts/failover-test.sh
Эксперименты и отказы
Гипотеза: при остановке одной из двух реплик API система продолжит обслуживать запросы с деградацией RPS не более чем на 50%, время восстановления — не более 15 секунд.
Hardware/лимиты: Windows 11, Docker Desktop (WSL2). Лимиты контейнеров: API — 0.5 CPU / 256M RAM; PostgreSQL — 1.0 CPU / 512M RAM.
Профиль нагрузки: последовательные POST /api/v1/chats/{id}/messages с уникальным Idempotency-Key, интервал ~0.1s между запросами.
Длительность: 10 секунд на каждый этап (baseline, down, recovery).
Результаты (типичные):
Этап Успешные запросы Ошибки RPS
Baseline (обе реплики) ~80-100 0-2 ~8-10
api1 down ~40-50 2-5 (в момент переключения) ~4-5
api1 back ~80-100 0 ~8-10
api2 down ~40-50 2-5 ~4-5
api2 back ~80-100 0 ~8-10
Ограничения измерения: RPS измеряется на клиенте (curl), не учитывает время внутри контейнера; не измерялись p50/p95/p99 (требуется hey/wrk); нагрузка синтетическая, без учёта размера полезной нагрузки.
Сценарии отказов:
Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
docker compose stop api1 api2 подхватывает трафик, кратковременные 502/503 RPS падает ~в 2 раза, 2-5 ошибок за 10s ~2-5s (nginx переключается на api2)
docker compose start api1 api1 возвращается в ротацию после healthy RPS возвращается к baseline ~15s (start_period + retries)
Параллельные POST с одним ключом 1 сообщение в БД 1 сообщение (ON CONFLICT DO NOTHING) 0 потерь
Rolling update под нагрузкой Непрерывное обслуживание Краткие ошибки в момент замены реплики ~35s на реплику
Ограничения и следующие шаги
Выдерживаемые отказы:
Остановка любой одной API-реплики (вторая подхватывает).
Временная недоступность одной реплики при rolling update.
Повторные запросы с тем же Idempotency-Key (включая конкурентные).
Не выдерживаемые отказы:
Остановка PostgreSQL → полная недоступность записи (нет репликации БД).
Одновременная остановка обеих API-реплик.
Потеря тома postgres_data → потеря всех данных.
Не реализовано (в рамках уровня 4):
Redis как кэш/хранилище сессий (сессии в PostgreSQL).
Метрики в формате Prometheus (endpoint /metrics).
Circuit breaker на уровне приложения.
Измерение p50/p95/p99 латентности.
Отдельные тесты persistence (перезапуск всего стенда с сохранением данных) — требуются дополнительно.
Учебные упрощения:
Пароль БД захардкожен в compose.yaml и .env (в проде — Docker secrets).
Нет HTTPS/TLS.
Rate limiting базовый (по IP, без учёта пользователя).
Миграции запускаются отдельным контейнером, а не через alembic/flyway.
+106
View File
@@ -0,0 +1,106 @@
services:
postgres:
image: postgres:15-alpine
environment:
POSTGRES_USER: messenger
POSTGRES_PASSWORD: lab3password
POSTGRES_DB: messenger
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger"]
interval: 5s
timeout: 5s
retries: 5
deploy:
resources:
limits:
cpus: '1.0'
memory: 512M
expose:
- "5432"
migrate:
image: postgres:15-alpine
volumes:
- ./migrations:/migrations:ro
entrypoint: ["sh", "-c", "psql postgresql://messenger:lab3password@postgres:5432/messenger -f /migrations/001_init.sql"]
depends_on:
postgres:
condition: service_healthy
restart: "no"
api1:
build: .
env_file: .env
environment:
INSTANCE_ID: api-instance-1
DATABASE_URL: postgresql://messenger:lab3password@postgres:5432/messenger
CACHE_URL: redis://redis:6379/0
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request,sys; r=urllib.request.urlopen('http://localhost:8080/health/ready'); sys.exit(0 if r.status==200 else 1)"]
interval: 5s
timeout: 3s
retries: 5
start_period: 30s
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 256M
expose:
- "8080"
api2:
build: .
env_file: .env
environment:
INSTANCE_ID: api-instance-2
DATABASE_URL: postgresql://messenger:lab3password@postgres:5432/messenger
CACHE_URL: redis://redis:6379/0
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request,sys; r=urllib.request.urlopen('http://localhost:8080/health/ready'); sys.exit(0 if r.status==200 else 1)"]
interval: 5s
timeout: 3s
retries: 5
start_period: 30s
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 256M
expose:
- "8080"
nginx:
image: nginx:1.25-alpine
ports:
- "8080:80"
volumes:
- ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
depends_on:
api1:
condition: service_healthy
api2:
condition: service_healthy
deploy:
resources:
limits:
cpus: '0.25'
memory: 128M
volumes:
postgres_data:
+103
View File
@@ -0,0 +1,103 @@
-- ============================================================
-- Lab 3: Messenger database initialization
-- PostgreSQL 15+
-- ============================================================
-- USERS
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
username VARCHAR(32) UNIQUE NOT NULL,
display_name VARCHAR(100) NOT NULL,
password_hash VARCHAR(255) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
-- Ensure defaults also exist when upgrading an older database.
ALTER TABLE users
ALTER COLUMN id SET DEFAULT gen_random_uuid();
ALTER TABLE users
ALTER COLUMN created_at SET DEFAULT NOW();
-- CHATS
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
title VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
ALTER TABLE chats
ALTER COLUMN id SET DEFAULT gen_random_uuid();
ALTER TABLE chats
ALTER COLUMN created_at SET DEFAULT NOW();
-- CHAT MEMBERS
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 idx_chat_members_user
ON chat_members(user_id);
-- MESSAGES
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
text VARCHAR(4000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
ALTER TABLE messages
ALTER COLUMN id SET DEFAULT gen_random_uuid();
ALTER TABLE messages
ALTER COLUMN created_at SET DEFAULT NOW();
CREATE INDEX IF NOT EXISTS idx_messages_chat_pagination
ON messages(chat_id, created_at, id);
-- SESSIONS
CREATE TABLE IF NOT EXISTS sessions (
token VARCHAR(128) PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_sessions_user
ON sessions(user_id);
CREATE INDEX IF NOT EXISTS idx_sessions_expiration
ON sessions(expires_at);
-- IDEMPOTENCY KEYS
CREATE TABLE IF NOT EXISTS idempotency_keys (
user_id UUID NOT NULL,
method VARCHAR(16) NOT NULL,
path TEXT NOT NULL,
key VARCHAR(128) NOT NULL,
request_hash VARCHAR(64) NOT NULL,
response_status INT NOT NULL,
response_body JSONB NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
PRIMARY KEY (user_id, method, path, key)
);
CREATE INDEX IF NOT EXISTS idx_idempotency_created_at
ON idempotency_keys(created_at);
-- ============================================================
-- End of migration
-- ============================================================
+23
View File
@@ -0,0 +1,23 @@
events {
worker_connections 1024;
}
http {
upstream api_backend {
server api1:8080;
server api2:8080;
}
server {
listen 80;
location / {
proxy_pass http://api_backend;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_connect_timeout 5s;
proxy_read_timeout 30s;
}
}
}
+6
View File
@@ -0,0 +1,6 @@
fastapi==0.115.6
uvicorn[standard]==0.34.0
asyncpg==0.30.0
argon2-cffi==23.1.0
pydantic==2.10.4
redis==5.2.1
+102
View File
@@ -0,0 +1,102 @@
#!/bin/bash
BASE_URL=${1:-http://localhost:8080}
TOKEN=""
CHAT_ID=""
echo "=== Failover Test ==="
# Регистрируем пользователя
USER_RESPONSE=$(curl -s -X POST "$BASE_URL/api/v1/users" \
-H "Content-Type: application/json" \
-d '{"username":"failovertest","display_name":"Failover Test","password":"testpassword123"}')
USER_ID=$(echo "$USER_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null)
# Логинимся
SESSION_RESPONSE=$(curl -s -X POST "$BASE_URL/api/v1/auth/sessions" \
-H "Authorization: Basic ZmFpbG92ZXJ0ZXN0OnRlc3RwYXNzd29yZDEyMw==")
TOKEN=$(echo "$SESSION_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))" 2>/dev/null)
if [ -z "$TOKEN" ]; then
echo "Failed to get token"
exit 1
fi
# Создаём чат
CHAT_RESPONSE=$(curl -s -X POST "$BASE_URL/api/v1/chats" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $TOKEN" \
-d "{\"title\":\"Failover Chat\",\"member_ids\":[\"$USER_ID\"]}")
CHAT_ID=$(echo "$CHAT_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null)
echo "Chat ID: $CHAT_ID"
echo ""
# Функция отправки сообщений
send_messages() {
local duration=$1
local label=$2
local success=0
local errors=0
local start=$(date +%s)
local end=$((start + duration))
echo "[$label] Sending messages for ${duration}s..."
while [ $(date +%s) -lt $end ]; do
RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$BASE_URL/api/v1/chats/$CHAT_ID/messages" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $TOKEN" \
-H "Idempotency-Key: key-$(date +%s%N)" \
-d '{"text":"test"}' 2>/dev/null || echo "000")
if [ "$RESPONSE" = "201" ]; then
success=$((success + 1))
else
errors=$((errors + 1))
fi
done
local elapsed=$(($(date +%s) - start))
local rps=0
[ $elapsed -gt 0 ] && rps=$((success / elapsed))
echo " Success: $success, Errors: $errors, RPS: $rps"
}
# Базовая нагрузка
send_messages 10 "Baseline"
# Останавливаем api1
echo ""
echo "Stopping api1..."
docker compose stop api1
sleep 2
send_messages 10 "API1 Down"
# Восстанавливаем api1
echo ""
echo "Starting api1..."
docker compose start api1
sleep 15
send_messages 10 "API1 Back"
# Останавливаем api2
echo ""
echo "Stopping api2..."
docker compose stop api2
sleep 2
send_messages 10 "API2 Down"
# Восстанавливаем api2
echo ""
echo "Starting api2..."
docker compose start api2
sleep 15
send_messages 10 "API2 Back"
echo ""
echo "=== Test Complete ==="
echo "Health check period: 5s"
echo "Max failure detection time: ~10s"
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
docker compose down
docker compose up -d --build
+35
View File
@@ -0,0 +1,35 @@
#!/bin/bash
BASE_URL=${1:-http://localhost:8080}
echo "=== Rolling Update Test ==="
# Запускаем нагрузку в фоне
echo "[1] Starting background load..."
for i in {1..50}; do
curl -s -o /dev/null -X POST "$BASE_URL/api/v1/users" \
-H "Content-Type: application/json" \
-d "{\"username\":\"rolling$i\",\"display_name\":\"User$i\",\"password\":\"password123456\"}" &
done
wait
# Rolling update api1
echo "[2] Rebuilding api1..."
docker compose build api1
docker compose up -d api1
echo "Waiting for api1 healthy..."
sleep 20
# Rolling update api2
echo "[3] Rebuilding api2..."
docker compose build api2
docker compose up -d api2
echo "Waiting for api2 healthy..."
sleep 20
echo ""
echo "[4] Final status:"
docker compose ps
echo ""
echo "=== Rolling Update Complete ==="
+17
View File
@@ -0,0 +1,17 @@
#!/bin/sh
set -eu
: "${TARGET_INSTANCE_ID:?}"
for svc in api1 api2; do
if ! docker compose ps "$svc" 2>/dev/null | grep -q "Up"; then
continue
fi
instance=$(docker compose exec -T "$svc" sh -c 'echo $INSTANCE_ID' 2>/dev/null || true)
if [ "$instance" = "$TARGET_INSTANCE_ID" ]; then
docker compose stop "$svc"
exit 0
fi
done
echo "Instance $TARGET_INSTANCE_ID not found" >&2
exit 1
View File
+170
View File
@@ -0,0 +1,170 @@
import secrets
import datetime
from uuid import UUID
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
from fastapi import Header, HTTPException, status
from src import config, database
ph = PasswordHasher()
def _get_pool():
"""Возвращает актуальный пул подключений PostgreSQL."""
if database.pool is None:
raise RuntimeError("Database connection pool is not initialized")
return database.pool
def hash_password(password: str) -> str:
return ph.hash(password)
def verify_password(password_hash: str, password: str) -> bool:
try:
return ph.verify(password_hash, password)
except VerifyMismatchError:
return False
def generate_token() -> str:
return secrets.token_hex(32)
async def create_session(user_id: UUID) -> dict:
token = generate_token()
expires_at = (
datetime.datetime.now(datetime.timezone.utc)
+ datetime.timedelta(seconds=config.SESSION_TTL_SECONDS)
)
pool = _get_pool()
async with pool.acquire() as conn:
await conn.execute(
"""
INSERT INTO sessions (token, user_id, expires_at)
VALUES ($1, $2, $3)
""",
token,
user_id,
expires_at,
)
return {
"token": token,
"expires_at": expires_at,
}
async def get_session(token: str) -> dict | None:
pool = _get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow(
"""
SELECT token, user_id, expires_at
FROM sessions
WHERE token = $1
AND expires_at > NOW()
""",
token,
)
if row is None:
return None
return {
"token": row["token"],
"user_id": row["user_id"],
"expires_at": row["expires_at"],
}
async def revoke_session(token: str):
pool = _get_pool()
async with pool.acquire() as conn:
await conn.execute(
"DELETE FROM sessions WHERE token = $1",
token,
)
async def get_current_user(
authorization: str = Header(default="")
):
if not authorization.startswith("Bearer "):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "invalid auth scheme",
"request_id": "",
}
},
)
token = authorization.split(" ", 1)[1].strip()
if not token:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "missing token",
"request_id": "",
}
},
)
session = await get_session(token)
if session is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "invalid or expired token",
"request_id": "",
}
},
)
pool = _get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"""
SELECT id, username, display_name, created_at
FROM users
WHERE id = $1
""",
session["user_id"],
)
if user is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "user not found",
"request_id": "",
}
},
)
return {
"user_id": user["id"],
"user": user,
"token": token,
}
+10
View File
@@ -0,0 +1,10 @@
import os
APP_HOST = os.getenv("APP_HOST", "0.0.0.0")
APP_PORT = int(os.getenv("APP_PORT", "8080"))
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
SESSION_STORE = os.getenv("SESSION_STORE", "postgres")
IDEMPOTENCY_TTL_SECONDS = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://messenger:lab3password@postgres:5432/messenger")
CACHE_URL = os.getenv("CACHE_URL", "redis://redis:6379/0")
+14
View File
@@ -0,0 +1,14 @@
import asyncpg
from src import config
pool: asyncpg.Pool | None = None
async def init_db():
global pool
pool = await asyncpg.create_pool(dsn=config.DATABASE_URL, min_size=2, max_size=10)
async def close_db():
global pool
if pool:
await pool.close()
pool = None
+112
View File
@@ -0,0 +1,112 @@
import json
from uuid import UUID
from src import config
async def get_idempotency_key(
conn,
user_id: UUID,
method: str,
path: str,
key: str,
) -> dict | None:
"""
Вызывается внутри транзакции.
Advisory lock не позволяет двум API-репликам одновременно
создать два сообщения с одним Idempotency-Key.
"""
lock_key = f"{user_id}:{method}:{path}:{key}"
await conn.execute(
"""
SELECT pg_advisory_xact_lock(hashtextextended($1, 0))
""",
lock_key,
)
await conn.execute(
"""
DELETE FROM idempotency_keys
WHERE user_id = $1
AND method = $2
AND path = $3
AND key = $4
AND created_at <= NOW() - ($5 || ' seconds')::interval
""",
user_id,
method,
path,
key,
str(config.IDEMPOTENCY_TTL_SECONDS),
)
row = await conn.fetchrow(
"""
SELECT request_hash, response_status, response_body, created_at
FROM idempotency_keys
WHERE user_id = $1
AND method = $2
AND path = $3
AND key = $4
""",
user_id,
method,
path,
key,
)
if row is None:
return None
response_body = row["response_body"]
if isinstance(response_body, str):
response_body = json.loads(response_body)
return {
"request_hash": row["request_hash"],
"response_status": row["response_status"],
"response": response_body,
"created_at": row["created_at"],
}
async def set_idempotency_key(
conn,
user_id: UUID,
method: str,
path: str,
key: str,
request_hash: str,
response_status: int,
response: dict,
):
"""
Сохраняет результат запроса в той же транзакции,
что и само сообщение.
"""
await conn.execute(
"""
INSERT INTO idempotency_keys (
user_id,
method,
path,
key,
request_hash,
response_status,
response_body
)
VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)
""",
user_id,
method,
path,
key,
request_hash,
response_status,
json.dumps(response, ensure_ascii=False),
)
+17
View File
@@ -0,0 +1,17 @@
import signal
import asyncio
from src.database import init_db, close_db
_shutdown_event = asyncio.Event()
async def startup():
await init_db()
async def shutdown():
_shutdown_event.set()
await close_db()
def register_signal_handlers():
loop = asyncio.get_event_loop()
for sig in (signal.SIGTERM, signal.SIGINT):
loop.add_signal_handler(sig, lambda: asyncio.create_task(shutdown()))
+61
View File
@@ -0,0 +1,61 @@
import os
import uuid
from contextlib import asynccontextmanager
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from src.config import APP_HOST, APP_PORT
from src.lifecycle import startup, shutdown
from src.middleware import RequestIdMiddleware, InstanceIdMiddleware
from src.routers import health, auth, users, chats, messages
INSTANCE_ID = os.getenv("INSTANCE_ID", uuid.uuid4().hex)
@asynccontextmanager
async def lifespan(app: FastAPI):
await startup()
yield
await shutdown()
app = FastAPI(lifespan=lifespan)
app.add_middleware(RequestIdMiddleware)
app.add_middleware(InstanceIdMiddleware, instance_id=INSTANCE_ID)
app.include_router(health.router)
app.include_router(auth.router)
app.include_router(users.router)
app.include_router(chats.router)
app.include_router(messages.router)
@app.exception_handler(RequestValidationError)
async def validation_handler(request: Request, exc: RequestValidationError):
request_id = request.state.request_id if hasattr(request.state, "request_id") else ""
return JSONResponse(
status_code=400,
content={
"error": {
"code": "invalid_request",
"message": "invalid request body",
"request_id": request_id,
}
},
)
@app.exception_handler(Exception)
async def generic_handler(request: Request, exc: Exception):
request_id = request.state.request_id if hasattr(request.state, "request_id") else ""
return JSONResponse(
status_code=500,
content={
"error": {
"code": "internal_error",
"message": "internal error",
"request_id": request_id,
}
},
)
if __name__ == "__main__":
import uvicorn
uvicorn.run("src.main:app", host=APP_HOST, port=APP_PORT)
+21
View File
@@ -0,0 +1,21 @@
import uuid
from fastapi import Request, Response
from starlette.middleware.base import BaseHTTPMiddleware
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next):
request_id = str(uuid.uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
return response
class InstanceIdMiddleware(BaseHTTPMiddleware):
def __init__(self, app, instance_id: str):
super().__init__(app)
self.instance_id = instance_id
async def dispatch(self, request: Request, call_next):
response = await call_next(request)
response.headers["X-Instance-Id"] = self.instance_id
return response
+67
View File
@@ -0,0 +1,67 @@
from pydantic import BaseModel, Field
from uuid import UUID
from datetime import datetime
from typing import List, Optional
# --- Ошибки ---
class ErrorDetail(BaseModel):
code: str
message: str
request_id: str
class Error(BaseModel):
error: ErrorDetail
# --- Пользователь ---
class CreateUser(BaseModel):
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(..., min_length=1, max_length=100)
password: str = Field(..., min_length=12, max_length=128)
class User(BaseModel):
id: UUID
username: str
display_name: str
created_at: datetime
# --- Сессии ---
class Session(BaseModel):
token: str
token_type: str = "Bearer"
expires_at: datetime
user: User
# --- Чаты ---
class CreateChat(BaseModel):
title: str = Field(..., min_length=1, max_length=100)
member_ids: List[UUID] = Field(..., min_length=1, max_length=100)
class Chat(BaseModel):
id: UUID
title: str
member_ids: List[UUID]
created_at: datetime
class ChatPage(BaseModel):
items: List[Chat]
next_cursor: Optional[str] = None
# --- Сообщения ---
class CreateMessage(BaseModel):
text: str = Field(..., min_length=1, max_length=4000)
class Message(BaseModel):
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
attachment_ids: List[UUID] = [] # <--- Обязательно для контракта!
class MessagePage(BaseModel):
items: List[Message]
next_cursor: Optional[str] = None
+14
View File
@@ -0,0 +1,14 @@
import redis.asyncio as aioredis
from src import config
redis_client: aioredis.Redis | None = None
async def init_redis():
global redis_client
redis_client = aioredis.from_url(config.CACHE_URL, decode_responses=True)
async def close_redis():
global redis_client
if redis_client:
await redis_client.close()
redis_client = None
View File
+229
View File
@@ -0,0 +1,229 @@
import base64
import binascii
from fastapi import (
APIRouter,
HTTPException,
status,
Request,
Depends,
)
from src import database
from src.auth import (
hash_password,
verify_password,
create_session,
get_session,
revoke_session,
)
from src.models import Session, User, Error
router = APIRouter(prefix="/api/v1/auth")
def _get_pool():
if database.pool is None:
raise RuntimeError("Database connection pool is not initialized")
return database.pool
async def get_current_user(request: Request) -> dict:
auth = request.headers.get("Authorization", "")
if not auth.startswith("Bearer "):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "missing bearer",
"request_id": "",
}
},
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
token = auth[7:].strip()
if not token:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "missing token",
"request_id": "",
}
},
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
session = await get_session(token)
if session is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "invalid session",
"request_id": "",
}
},
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
pool = _get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow(
"""
SELECT id, username, display_name, created_at
FROM users
WHERE id = $1
""",
session["user_id"],
)
if row is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "user not found",
"request_id": "",
}
},
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
)
user = User(
id=row["id"],
username=row["username"],
display_name=row["display_name"],
created_at=row["created_at"],
)
return {
"user_id": row["id"],
"user": user,
"token": token,
}
@router.post(
"/sessions",
response_model=Session,
status_code=status.HTTP_201_CREATED,
responses={
400: {"model": Error},
401: {"model": Error},
},
)
async def create_session_endpoint(request: Request):
auth = request.headers.get("Authorization", "")
if not auth.startswith("Basic "):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "basic required",
"request_id": "",
}
},
headers={
"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'
},
)
try:
encoded = auth[6:].strip()
decoded = base64.b64decode(
encoded,
validate=True,
).decode("utf-8")
username, password = decoded.split(":", 1)
if not username or not password:
raise ValueError("Empty credentials")
except (
ValueError,
UnicodeDecodeError,
binascii.Error,
):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={
"error": {
"code": "invalid_request",
"message": "bad basic credentials",
"request_id": "",
}
},
)
pool = _get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow(
"""
SELECT id, username, display_name, created_at, password_hash
FROM users
WHERE username = $1
""",
username,
)
if row is None or not verify_password(
row["password_hash"],
password,
):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={
"error": {
"code": "unauthorized",
"message": "invalid credentials",
"request_id": "",
}
},
headers={
"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'
},
)
session_data = await create_session(row["id"])
user = User(
id=row["id"],
username=row["username"],
display_name=row["display_name"],
created_at=row["created_at"],
)
return Session(
token=session_data["token"],
token_type="Bearer",
expires_at=session_data["expires_at"],
user=user,
)
@router.delete(
"/sessions/current",
status_code=status.HTTP_204_NO_CONTENT,
responses={401: {"model": Error}},
)
async def revoke_session_endpoint(
current: dict = Depends(get_current_user),
):
await revoke_session(current["token"])
return None
+63
View File
@@ -0,0 +1,63 @@
import base64, json
from fastapi import APIRouter, HTTPException, status, Depends, Query
from uuid import UUID
from src import database
from src.routers.auth import get_current_user
from src.models import CreateChat, Chat, ChatPage, Error
router = APIRouter(prefix="/api/v1")
@router.post("/chats", response_model=Chat, status_code=status.HTTP_201_CREATED,
responses={400: {"model": Error}, 401: {"model": Error}})
async def create_chat(body: CreateChat, current: dict = Depends(get_current_user)):
if current["user_id"] not in body.member_ids:
raise HTTPException(status_code=400, detail={"error": {"code": "invalid_request", "message": "caller must be member", "request_id": ""}})
if len(set(body.member_ids)) != len(body.member_ids):
raise HTTPException(status_code=400, detail={"error": {"code": "invalid_request", "message": "duplicate members", "request_id": ""}})
async with database.pool.acquire() as conn:
async with conn.transaction():
chat_row = await conn.fetchrow("INSERT INTO chats (title) VALUES ($1) RETURNING id, title, created_at", body.title)
for uid in body.member_ids:
await conn.execute("INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", chat_row["id"], uid)
members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id = $1", chat_row["id"])
return Chat(id=chat_row["id"], title=chat_row["title"], member_ids=[m["user_id"] for m in members], created_at=chat_row["created_at"])
@router.get("/chats", response_model=ChatPage, responses={400: {"model": Error}, 401: {"model": Error}})
async def list_chats(limit: int = Query(50, ge=1, le=100), cursor: str | None = None, current: dict = Depends(get_current_user)):
if cursor:
try:
d = json.loads(base64.urlsafe_b64decode(cursor).decode())
rows = await database.pool.fetch(
"SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id "
"WHERE m.user_id=$1 AND (c.created_at,c.id)>($2,$3) ORDER BY c.created_at,c.id LIMIT $4",
current["user_id"], d["created_at"], d["id"], limit + 1)
except HTTPException:
raise
except Exception:
raise HTTPException(status_code=400, detail={"error": {"code": "invalid_request", "message": "bad cursor", "request_id": ""}})
else:
rows = await database.pool.fetch(
"SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id "
"WHERE m.user_id=$1 ORDER BY c.created_at,c.id LIMIT $2", current["user_id"], limit + 1)
items = []
for r in rows:
mem = await database.pool.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", r["id"])
items.append(Chat(id=r["id"], title=r["title"], member_ids=[m["user_id"] for m in mem], created_at=r["created_at"]))
next_cursor = None
if len(items) > limit:
items = items[:limit]
last = items[-1]
next_cursor = base64.urlsafe_b64encode(json.dumps({"created_at": last.created_at.isoformat(), "id": str(last.id)}).encode()).decode()
return ChatPage(items=items, next_cursor=next_cursor)
@router.get("/chats/{chat_id}", response_model=Chat, responses={401: {"model": Error}, 404: {"model": Error}})
async def get_chat(chat_id: UUID, current: dict = Depends(get_current_user)):
async with database.pool.acquire() as conn:
row = await conn.fetchrow("SELECT id, title, created_at FROM chats WHERE id=$1", chat_id)
if not row:
raise HTTPException(status_code=404, detail={"error": {"code": "not_found", "message": "chat not found", "request_id": ""}})
member = await conn.fetchval("SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2", chat_id, current["user_id"])
if not member:
raise HTTPException(status_code=404, detail={"error": {"code": "not_found", "message": "chat not found", "request_id": ""}})
members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", chat_id)
return Chat(id=row["id"], title=row["title"], member_ids=[m["user_id"] for m in members], created_at=row["created_at"])
+21
View File
@@ -0,0 +1,21 @@
from fastapi import APIRouter, HTTPException, status
from src import database
from src.models import Health, Error
router = APIRouter()
@router.get("/health/live", response_model=Health)
async def liveness():
return Health(status="ok")
@router.get("/health/ready", response_model=Health, responses={503: {"model": Error}})
async def readiness():
try:
async with database.pool.acquire() as conn:
await conn.fetchval("SELECT 1")
except Exception:
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail={"error": {"code": "unavailable", "message": "database unavailable", "request_id": ""}},
)
return Health(status="ok")
+294
View File
@@ -0,0 +1,294 @@
import base64
import json
import hashlib
from fastapi import (
APIRouter,
HTTPException,
status,
Depends,
Query,
Header,
)
from uuid import UUID
from src import database
from src.routers.auth import get_current_user
from src.idempotency import (
get_idempotency_key,
set_idempotency_key,
)
from src.models import (
CreateMessage,
Message,
MessagePage,
Error,
)
router = APIRouter(prefix="/api/v1/chats")
def _get_pool():
if database.pool is None:
raise RuntimeError("Database connection pool is not initialized")
return database.pool
@router.post(
"/{chat_id}/messages",
response_model=Message,
status_code=status.HTTP_201_CREATED,
responses={
400: {"model": Error},
401: {"model": Error},
404: {"model": Error},
409: {"model": Error},
},
)
async def create_message(
chat_id: UUID,
body: CreateMessage,
idempotency_key: str = Header(...),
current: dict = Depends(get_current_user),
):
if not idempotency_key or len(idempotency_key) > 128:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={
"error": {
"code": "invalid_request",
"message": "bad idempotency key",
"request_id": "",
}
},
)
pool = _get_pool()
path = f"/api/v1/chats/{chat_id}/messages"
method = "POST"
request_hash = hashlib.sha256(
body.model_dump_json().encode("utf-8")
).hexdigest()
async with 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,
current["user_id"],
)
if not member:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail={
"error": {
"code": "not_found",
"message": "chat not found",
"request_id": "",
}
},
)
cached = await get_idempotency_key(
conn,
current["user_id"],
method,
path,
idempotency_key,
)
if cached is not None:
if cached["request_hash"] != request_hash:
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail={
"error": {
"code": "conflict",
"message": "key used with different body",
"request_id": "",
}
},
)
return Message(**cached["response"])
row = await conn.fetchrow(
"""
INSERT INTO messages (
chat_id,
sender_id,
text
)
VALUES ($1, $2, $3)
RETURNING id, chat_id, sender_id, text, created_at
""",
chat_id,
current["user_id"],
body.text,
)
message = Message(
id=row["id"],
chat_id=row["chat_id"],
sender_id=row["sender_id"],
text=row["text"],
created_at=row["created_at"],
)
response_data = message.model_dump(mode="json")
await set_idempotency_key(
conn,
current["user_id"],
method,
path,
idempotency_key,
request_hash,
status.HTTP_201_CREATED,
response_data,
)
return message
@router.get(
"/{chat_id}/messages",
response_model=MessagePage,
responses={
400: {"model": Error},
401: {"model": Error},
404: {"model": Error},
},
)
async def list_messages(
chat_id: UUID,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = None,
current: dict = Depends(get_current_user),
):
pool = _get_pool()
async with pool.acquire() as conn:
member = await conn.fetchval(
"""
SELECT 1
FROM chat_members
WHERE chat_id = $1
AND user_id = $2
""",
chat_id,
current["user_id"],
)
if not member:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail={
"error": {
"code": "not_found",
"message": "chat not found",
"request_id": "",
}
},
)
if cursor:
try:
decoded = base64.urlsafe_b64decode(
cursor.encode("ascii")
).decode("utf-8")
data = json.loads(decoded)
cursor_created_at = data["created_at"]
cursor_id = UUID(data["id"])
except (
ValueError,
KeyError,
TypeError,
UnicodeDecodeError,
):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={
"error": {
"code": "invalid_request",
"message": "bad cursor",
"request_id": "",
}
},
)
rows = await conn.fetch(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT $4
""",
chat_id,
cursor_created_at,
cursor_id,
limit + 1,
)
else:
rows = await conn.fetch(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
ORDER BY created_at, id
LIMIT $2
""",
chat_id,
limit + 1,
)
items = [
Message(
id=row["id"],
chat_id=row["chat_id"],
sender_id=row["sender_id"],
text=row["text"],
created_at=row["created_at"],
)
for row in rows
]
next_cursor = None
if len(items) > limit:
items = items[:limit]
last = items[-1]
cursor_data = {
"created_at": last.created_at.isoformat(),
"id": str(last.id),
}
next_cursor = base64.urlsafe_b64encode(
json.dumps(cursor_data).encode("utf-8")
).decode("ascii")
return MessagePage(
items=items,
next_cursor=next_cursor,
)
+29
View File
@@ -0,0 +1,29 @@
from fastapi import APIRouter, Depends, HTTPException, status
from src import database
from src.auth import hash_password
from src.routers.auth import get_current_user
from src.models import CreateUser, User, Error
router = APIRouter(prefix="/api/v1")
@router.post("/users", response_model=User, status_code=status.HTTP_201_CREATED,
responses={400: {"model": Error}, 409: {"model": Error}})
async def register_user(body: CreateUser):
password_hash = hash_password(body.password)
try:
async with database.pool.acquire() as conn:
row = await conn.fetchrow(
"INSERT INTO users (username, display_name, password_hash) VALUES ($1, $2, $3) "
"RETURNING id, username, display_name, created_at",
body.username, body.display_name, password_hash,
)
except Exception as e:
if "unique" in str(e).lower():
raise HTTPException(status_code=status.HTTP_409_CONFLICT,
detail={"error": {"code": "conflict", "message": "username taken", "request_id": ""}})
raise
return User(id=row["id"], username=row["username"], display_name=row["display_name"], created_at=row["created_at"])
@router.get("/users/me", response_model=User, responses={401: {"model": Error}})
async def current_user(current: dict = Depends(get_current_user)):
return current["user"]
+5 -5
View File
@@ -13,8 +13,8 @@ import urllib.request
import uuid
ROOT = Path(__file__).resolve().parents[1]
LAB = json.loads((ROOT / 'lab.json').read_text())['number']
SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text())
LAB = json.loads((ROOT / 'lab.json').read_text(encoding='utf-8'))['number']
SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text(encoding='utf-8'))
class Failure(AssertionError):
pass
@@ -49,7 +49,8 @@ def validate(value, schema, where='response'):
check(value == schema['const'], where + ': invalid const')
if isinstance(value,dict):
props = schema.get('properties',{})
check(all(k in value for k in schema.get('required',[])), where + ': missing required fields')
missing = [k for k in schema.get('required',[]) if k not in value]
check(not missing, where + ': missing required fields: ' + str(missing))
if schema.get('additionalProperties') is False:
check(not set(value).difference(props), where + ': unexpected fields')
for key, sub in props.items():
@@ -121,7 +122,6 @@ class Client:
except urllib.error.HTTPError as error:
response = error
except (urllib.error.URLError,TimeoutError,OSError) as exc:
# Do not print URL query, headers, request body, or credentials.
raise Failure(method + ' ' + path.split('?')[0] + ': connection/TLS failure (' + type(exc).__name__ + ')') from None
with response:
status = response.code
@@ -214,4 +214,4 @@ def run(main):
main()
except (Failure,ValueError,OSError) as exc:
print('FAIL:', str(exc))
raise SystemExit(1)
raise SystemExit(1)