From 2e23dbe09593c0fce7fe583557ef01c90befedbd Mon Sep 17 00:00:00 2001 From: "yurtaev.va" Date: Fri, 23 Oct 2026 18:54:43 +0300 Subject: [PATCH 1/3] feat: lab3 init --- .env.example | 15 +- Dockerfile | 10 + Makefile | 5 +- app/__init__.py | 0 app/main.py | 500 +++++++++++++++++++++++++++++++++ compose.yaml | 107 +++++++ infra/nginx.conf | 21 ++ infra/swarm-app.yaml | 66 +++++ infra/swarm-data.yaml | 41 +++ migrations/001_initial.sql | 38 +++ migrations/002_idempotency.sql | 10 + requirements.txt | 4 + scripts/lint.py | 49 ++++ scripts/migrate.py | 16 ++ scripts/restart.sh | 4 + scripts/stop-one.sh | 12 + 16 files changed, 886 insertions(+), 12 deletions(-) create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/main.py create mode 100644 compose.yaml create mode 100644 infra/nginx.conf create mode 100644 infra/swarm-app.yaml create mode 100644 infra/swarm-data.yaml create mode 100644 migrations/001_initial.sql create mode 100644 migrations/002_idempotency.sql create mode 100644 requirements.txt create mode 100644 scripts/lint.py create mode 100644 scripts/migrate.py create mode 100755 scripts/restart.sh create mode 100755 scripts/stop-one.sh diff --git a/.env.example b/.env.example index d32b9be0..55f87a7b 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,6 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 +# Local synthetic test only. Copy to .env and replace the password. APP_PORT=8080 -APP_ENV=lab -SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url API_REPLICAS=2 -IDEMPOTENCY_TTL_SECONDS=86400 +SESSION_TTL_SECONDS=3600 +POSTGRES_PASSWORD=replace-me-with-a-local-password +DB_POOL_SIZE=8 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..74909261 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,10 @@ +FROM python:3.12.10-slim +WORKDIR /app +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt && useradd -r -u 10001 app +COPY app ./app +COPY migrations ./migrations +COPY scripts/migrate.py ./scripts/migrate.py +USER app +EXPOSE 8080 +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--workers", "1"] diff --git a/Makefile b/Makefile index 5d86d171..f671ce5e 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate lint test load test-persistence test-failover help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -15,6 +15,9 @@ check: validate: $(PYTHON) scripts/validate_openapi.py +lint: + $(PYTHON) scripts/lint.py + test: $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..fee71a09 --- /dev/null +++ b/app/main.py @@ -0,0 +1,500 @@ +"""Replicated messenger API with PostgreSQL-backed sessions and idempotency.""" + +import asyncio +import base64 +import binascii +import hashlib +import json +import os +import re +import secrets +import socket +import threading +import time +import uuid +from contextlib import asynccontextmanager +from datetime import datetime, timedelta, timezone + +import psycopg +import redis +from fastapi import FastAPI, Request +from fastapi.responses import JSONResponse, Response +from psycopg.conninfo import make_conninfo +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool, PoolTimeout +from starlette.exceptions import HTTPException as StarletteHTTPException + + +DATABASE_URL = os.environ.get("DATABASE_URL", "postgresql://messenger:messenger@localhost:5432/messenger") +database_password = os.environ.get("DATABASE_PASSWORD") +if "DATABASE_PASSWORD_FILE" in os.environ: + with open(os.environ["DATABASE_PASSWORD_FILE"], encoding="utf-8") as secret_file: + database_password = secret_file.read().rstrip("\n") +if database_password is not None: + DATABASE_URL = make_conninfo( + host=os.environ.get("DATABASE_HOST", "postgres"), + dbname=os.environ.get("DATABASE_NAME", "messenger"), + user=os.environ.get("DATABASE_USER", "messenger"), + password=database_password, + ) +REDIS_URL = os.environ.get("REDIS_URL", "redis://localhost:6379/0") +SESSION_TTL = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) +MAX_BODY = int(os.environ.get("MAX_HTTP_BODY_BYTES", "16384")) +POOL_SIZE = int(os.environ.get("DB_POOL_SIZE", "10")) +CACHE_ENABLED = os.environ.get("CACHE_ENABLED", "1") == "1" +CACHE_LOCK_ENABLED = os.environ.get("CACHE_LOCK_ENABLED", "1") == "1" +CACHE_MISS_DELAY_MS = min(1000, max(0, int(os.environ.get("CACHE_MISS_DELAY_MS", "0")))) +INSTANCE_ID = os.environ.get("INSTANCE_ID", "") or socket.gethostname() +ready_for_traffic = False +pool = ConnectionPool(DATABASE_URL, min_size=1, max_size=POOL_SIZE, timeout=3, open=False, kwargs={"row_factory": dict_row, "connect_timeout": 3, "options": "-c statement_timeout=3000 -c lock_timeout=2000"}) +cache = redis.Redis.from_url(REDIS_URL, socket_connect_timeout=0.2, socket_timeout=0.2) +metrics = {"history_sql": 0, "history_cache_hit": 0, "history_lock_wait": 0} +metrics_lock = threading.Lock() + + +class ApiError(Exception): + def __init__(self, status, code, message, challenge=None): + self.status, self.code, self.message, self.challenge = status, code, message, challenge + + +def invalid(message="Некорректный запрос"): + raise ApiError(400, "invalid_request", message) + + +def unavailable(): + raise ApiError(503, "unavailable", "Хранилище временно недоступно") + + +def stamp(value): + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def encode_cursor(scope, date, identifier): + raw = json.dumps([scope, date, identifier], separators=(",", ":")).encode() + return base64.urlsafe_b64encode(raw).rstrip(b"=").decode() + + +def decode_cursor(scope, value): + if value is None: + return None + try: + raw = base64.urlsafe_b64decode(value + "=" * (-len(value) % 4)) + parts = json.loads(raw) + if (not isinstance(parts, list) or len(parts) != 3 or parts[0] != scope + or not isinstance(parts[1], str) or not isinstance(parts[2], str)): + invalid("Некорректный cursor") + date = datetime.fromisoformat(parts[1].replace("Z", "+00:00")) + if date.tzinfo is None: + invalid("Некорректный cursor") + return date, str(uuid.UUID(parts[2])) + except (ValueError, TypeError, binascii.Error, IndexError): + invalid("Некорректный cursor") + + +def identifier(value): + try: + result = str(uuid.UUID(value)) + if result != value.lower() or len(value) != 36: + invalid("Некорректный UUID") + return result + except (ValueError, TypeError, AttributeError): + invalid("Некорректный UUID") + + +def text_field(value, maximum): + if not isinstance(value, str) or not value.strip() or len(value) > maximum: + invalid("Некорректное текстовое поле") + return value + + +def exact_body(value, fields): + if not isinstance(value, dict) or set(value) != set(fields): + invalid("Некорректные поля JSON") + + +async def body(request, fields): + if request.headers.get("content-type", "").split(";")[0].strip().lower() != "application/json": + raise ApiError(415, "unsupported_media_type", "Ожидается application/json") + declared = request.headers.get("content-length") + if declared is not None and declared.isdecimal() and int(declared) > MAX_BODY: + raise ApiError(413, "payload_too_large", "Тело запроса слишком велико") + chunks = bytearray() + async for chunk in request.stream(): + chunks.extend(chunk) + if len(chunks) > MAX_BODY: + raise ApiError(413, "payload_too_large", "Тело запроса слишком велико") + try: + value = json.loads(chunks.decode("utf-8")) + except (UnicodeError, ValueError): + invalid("Некорректный JSON") + exact_body(value, fields) + return value + + +def user(row): + return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"], "created_at": stamp(row["created_at"])} + + +def message(row): + return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": row["text"], "created_at": stamp(row["created_at"])} + + +def chat(connection, row): + members = connection.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (row["id"],)).fetchall() + return {"id": str(row["id"]), "title": row["title"], "member_ids": [str(item["user_id"]) for item in members], "created_at": stamp(row["created_at"])} + + +def password_hash(password): + salt = os.urandom(16) + derived = hashlib.scrypt(password.encode(), salt=salt, n=16384, r=8, p=1) + return "scrypt:16384:8:1:" + salt.hex() + ":" + derived.hex() + + +def password_ok(password, stored): + try: + _, n, r, p, salt, expected = stored.split(":") + actual = hashlib.scrypt(password.encode(), salt=bytes.fromhex(salt), n=int(n), r=int(r), p=int(p)) + return secrets.compare_digest(actual, bytes.fromhex(expected)) + except (ValueError, TypeError): + return False + + +def connection(): + try: + return pool.connection() + except psycopg.Error: + unavailable() + + +def actor(request): + auth = request.headers.get("authorization", "") + if not auth.startswith("Bearer ") or not auth[7:]: + raise ApiError(401, "unauthorized", "Требуется сессия", 'Bearer realm="messenger"') + digest = hashlib.sha256(auth[7:].encode()).digest() + with connection() as db: + row = db.execute("SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()", (digest,)).fetchone() + if row is None: + raise ApiError(401, "unauthorized", "Требуется сессия", 'Bearer realm="messenger"') + return row["user_id"] + + +def member(db, uid, cid): + row = db.execute("SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s", (cid, uid)).fetchone() + if row is None: + raise ApiError(404, "not_found", "Объект не найден") + return row + + +def pagination(request): + raw = request.query_params.get("limit", "50") + if len(raw) > 20 or not re.fullmatch(r"[0-9]+", raw) or not 1 <= int(raw) <= 100: + invalid("Некорректный limit") + return int(raw) + + +def bump(key): + with metrics_lock: + metrics[key] += 1 + + +def cache_get(key): + try: + raw = cache.get(key) + if raw is not None: + bump("history_cache_hit") + return json.loads(raw) + except (redis.RedisError, ValueError): + pass + return None + + +def cache_set(key, data): + try: + cache.set(key, json.dumps(data), ex=30) + except redis.RedisError: + pass + + +def history(db, cid, limit, cursor, version): + key = f"history:{cid}:{version}:{limit}:{cursor or '-'}" + hit = cache_get(key) if CACHE_ENABLED else None + if hit is not None: + return hit + lock_key = "lock:" + key + token = secrets.token_hex(16) + locked = False + if CACHE_ENABLED and CACHE_LOCK_ENABLED: + try: + locked = bool(cache.set(lock_key, token, nx=True, px=2000)) + if not locked: + bump("history_lock_wait") + for _ in range(20): + time.sleep(0.025) + hit = cache_get(key) + if hit is not None: + return hit + locked = bool(cache.set(lock_key, token, nx=True, px=2000)) + except redis.RedisError: + pass + if CACHE_MISS_DELAY_MS: + time.sleep(CACHE_MISS_DELAY_MS / 1000) + if cursor is None: + rows = db.execute("SELECT * FROM messages WHERE chat_id=%s ORDER BY created_at,id LIMIT %s", (cid, limit + 1)).fetchall() + else: + rows = db.execute("SELECT * FROM messages WHERE chat_id=%s AND (created_at,id)>(%s,%s) ORDER BY created_at,id LIMIT %s", (cid, cursor[0], cursor[1], limit + 1)).fetchall() + bump("history_sql") + result = {"items": [message(row) for row in rows[:limit]], "next_cursor": None} + if len(rows) > limit: + last = rows[limit - 1] + result["next_cursor"] = encode_cursor(str(cid), stamp(last["created_at"]), str(last["id"])) + if CACHE_ENABLED: + cache_set(key, result) + if locked: + try: + cache.eval("if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) end", 1, lock_key, token) + except redis.RedisError: + pass + return result + + +def migrate(): + from pathlib import Path + files = sorted(Path(__file__).resolve().parent.parent.joinpath("migrations").glob("*.sql")) + with pool.connection() as db: + with db.transaction(): + db.execute("SELECT pg_advisory_xact_lock(2172002)") + db.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY)") + for file in files: + if db.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (file.name,)).fetchone() is None: + db.execute(file.read_text()) + db.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (file.name,)) + + +@asynccontextmanager +async def lifespan(_app): + global ready_for_traffic + pool.open() + pool.wait(timeout=20) + ready_for_traffic = True + yield + ready_for_traffic = False + pool.close() + + +app = FastAPI(lifespan=lifespan) + + +@app.exception_handler(StarletteHTTPException) +async def http_error(request, error): + request_id = request.state.request_id + code = "not_found" if error.status_code == 404 else "invalid_request" + return JSONResponse({"error": {"code": code, "message": "Объект не найден" if error.status_code == 404 else "Некорректный запрос", "request_id": request_id}}, status_code=error.status_code) + + +@app.middleware("http") +async def envelope(request, call_next): + request_id = str(uuid.uuid4()) + request.state.request_id = request_id + try: + response = await call_next(request) + except ApiError as exc: + response = JSONResponse({"error": {"code": exc.code, "message": exc.message, "request_id": request_id}}, status_code=exc.status) + if exc.challenge: + response.headers["WWW-Authenticate"] = exc.challenge + except (psycopg.OperationalError, psycopg.InterfaceError, psycopg.errors.QueryCanceled, + psycopg.errors.LockNotAvailable, PoolTimeout): + response = JSONResponse({"error": {"code": "unavailable", "message": "Хранилище временно недоступно", "request_id": request_id}}, status_code=503) + except Exception: + response = JSONResponse({"error": {"code": "internal_error", "message": "Внутренняя ошибка", "request_id": request_id}}, status_code=500) + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +@app.get("/health/live") +def live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def ready(): + if not ready_for_traffic: + unavailable() + with connection() as db: + db.execute("SELECT 1") + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +async def create_user(request: Request): + data = await body(request, ("username", "display_name", "password")) + name = data["username"] + if not isinstance(name, str) or not re.fullmatch(r"[a-z0-9_]{3,32}", name): + invalid("Некорректный username") + display = text_field(data["display_name"], 100) + password = data["password"] + if not isinstance(password, str) or not 12 <= len(password) <= 128: + invalid("Некорректный пароль") + try: + return await asyncio.to_thread(insert_user, name, display, password) + except psycopg.errors.UniqueViolation: + raise ApiError(409, "conflict", "Username уже занят") from None + + +def insert_user(name, display, password): + digest = password_hash(password) + with connection() as db: + row = db.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING *", (uuid.uuid4(), name, display, digest)).fetchone() + return user(row) + + +@app.post("/api/v1/auth/sessions", status_code=201) +async def login(request: Request): + async for chunk in request.stream(): + if chunk: + invalid("Тело запроса не допускается") + auth = request.headers.get("authorization", "") + try: + if not auth.startswith("Basic "): + raise ValueError() + decoded = base64.b64decode(auth[6:], validate=True).decode("utf-8") + name, password = decoded.split(":", 1) + except (ValueError, UnicodeError, binascii.Error): + raise ApiError(401, "unauthorized", "Неверные учётные данные", 'Basic realm="messenger", charset="UTF-8"') from None + return await asyncio.to_thread(create_session, name, password) + + +def create_session(name, password): + with connection() as db: + row = db.execute("SELECT * FROM users WHERE username=%s", (name,)).fetchone() + if row is None or not password_ok(password, row["password_hash"]): + raise ApiError(401, "unauthorized", "Неверные учётные данные", 'Basic realm="messenger", charset="UTF-8"') + token = secrets.token_urlsafe(32) + expiry = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL) + db.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,%s)", (hashlib.sha256(token.encode()).digest(), row["id"], expiry)) + return {"token": token, "token_type": "Bearer", "expires_at": stamp(expiry), "user": user(row)} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def logout(request: Request): + actor(request) + token = request.headers["authorization"][7:] + with connection() as db: + db.execute("DELETE FROM sessions WHERE token_hash=%s", (hashlib.sha256(token.encode()).digest(),)) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +def me(request: Request): + uid = actor(request) + with connection() as db: + row = db.execute("SELECT * FROM users WHERE id=%s", (uid,)).fetchone() + return user(row) + + +@app.post("/api/v1/chats", status_code=201) +async def create_chat(request: Request): + uid = actor(request) + data = await body(request, ("title", "member_ids")) + title = text_field(data["title"], 100) + raw = data["member_ids"] + if not isinstance(raw, list) or not 1 <= len(raw) <= 100: + invalid("Некорректный список участников") + members = [identifier(item) for item in raw] + if len(set(members)) != len(members) or str(uid) not in members: + invalid("Некорректный список участников") + return await asyncio.to_thread(insert_chat, uid, title, members) + + +def insert_chat(uid, title, members): + with connection() as db: + with db.transaction(): + count = db.execute("SELECT count(*) AS n FROM users WHERE id = ANY(%s::uuid[])", (members,)).fetchone()["n"] + if count != len(members): + invalid("Неизвестный участник") + row = db.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING *", (uuid.uuid4(), title)).fetchone() + for member_id in members: + db.execute("INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)", (row["id"], member_id)) + db.execute("INSERT INTO chat_versions(chat_id) VALUES (%s)", (row["id"],)) + return chat(db, row) + + +@app.get("/api/v1/chats") +def list_chats(request: Request): + uid = actor(request) + limit = pagination(request) + cursor = decode_cursor("chats:" + str(uid), request.query_params.get("cursor")) + with connection() as db: + if cursor is None: + rows = db.execute("SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s ORDER BY c.created_at,c.id LIMIT %s", (uid, limit + 1)).fetchall() + else: + valid = db.execute("SELECT 1 FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s AND c.created_at=%s AND c.id=%s", (uid, cursor[0], cursor[1])).fetchone() + if valid is None: + invalid("Некорректный cursor") + rows = db.execute("SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s AND (c.created_at,c.id)>(%s,%s) ORDER BY c.created_at,c.id LIMIT %s", (uid, cursor[0], cursor[1], limit + 1)).fetchall() + items = [chat(db, row) for row in rows[:limit]] + next_cursor = encode_cursor("chats:" + str(uid), stamp(rows[limit - 1]["created_at"]), str(rows[limit - 1]["id"])) if len(rows) > limit else None + return {"items": items, "next_cursor": next_cursor} + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: str, request: Request): + uid = actor(request) + cid = identifier(chat_id) + with connection() as db: + return chat(db, member(db, uid, cid)) + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def create_message(chat_id: str, request: Request): + uid = actor(request) + cid = identifier(chat_id) + key = request.headers.get("idempotency-key", "") + if not re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", key, flags=re.ASCII): + invalid("Некорректный Idempotency-Key") + data = await body(request, ("text",)) + content = text_field(data["text"], 4000) + return await asyncio.to_thread(insert_message, uid, cid, content, key) + + +def insert_message(uid, cid, content, key): + with connection() as db: + with db.transaction(): + member(db, uid, cid) + # The unique constraint serializes concurrent requests on any replica. + db.execute("DELETE FROM message_idempotency WHERE user_id=%s AND chat_id=%s AND key=%s AND expires_at<=clock_timestamp()", (uid, cid, key)) + claimed = db.execute("INSERT INTO message_idempotency(user_id,chat_id,key,body_hash,expires_at) VALUES (%s,%s,%s,%s,clock_timestamp()+interval '24 hours') ON CONFLICT DO NOTHING RETURNING key", (uid, cid, key, hashlib.sha256(json.dumps({"text": content}, ensure_ascii=False, sort_keys=True).encode()).digest())).fetchone() + if claimed is None: + previous = db.execute("SELECT body_hash,message_id FROM message_idempotency WHERE user_id=%s AND chat_id=%s AND key=%s", (uid, cid, key)).fetchone() + expected = hashlib.sha256(json.dumps({"text": content}, ensure_ascii=False, sort_keys=True).encode()).digest() + if previous is None or previous["body_hash"] != expected: + raise ApiError(409, "conflict", "Ключ уже использован для другого сообщения") + return message(db.execute("SELECT * FROM messages WHERE id=%s", (previous["message_id"],)).fetchone()) + row = db.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *", (uuid.uuid4(), cid, uid, content)).fetchone() + db.execute("UPDATE message_idempotency SET message_id=%s WHERE user_id=%s AND chat_id=%s AND key=%s", (row["id"], uid, cid, key)) + db.execute("UPDATE chat_versions SET version=version+1 WHERE chat_id=%s", (cid,)) + return message(row) + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages(chat_id: str, request: Request): + uid = actor(request) + cid = identifier(chat_id) + limit = pagination(request) + cursor = decode_cursor(cid, request.query_params.get("cursor")) + with connection() as db: + member(db, uid, cid) + if cursor is not None: + valid = db.execute("SELECT 1 FROM messages WHERE chat_id=%s AND created_at=%s AND id=%s", (cid, cursor[0], cursor[1])).fetchone() + if valid is None: + invalid("Некорректный cursor") + version = db.execute("SELECT version FROM chat_versions WHERE chat_id=%s", (cid,)).fetchone()["version"] + return history(db, cid, limit, cursor, version) + + +@app.get("/internal/cache-metrics") +def cache_metrics(request: Request): + if not os.environ.get("ENABLE_EXPERIMENT_METRICS") or request.client.host not in ("127.0.0.1", "::1"): + raise ApiError(404, "not_found", "Объект не найден") + with metrics_lock: + return dict(metrics) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..261dc824 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,107 @@ +services: + postgres: + image: postgres:16.8-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + volumes: + - postgres_data:/var/lib/postgresql/data + networks: [data] + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 3s + timeout: 2s + retries: 20 + deploy: + resources: + limits: + cpus: "1.0" + memory: 512M + + redis: + image: redis:7.4.2-alpine + command: ["redis-server", "--save", "", "--appendonly", "no", "--maxmemory", "128mb", "--maxmemory-policy", "allkeys-lru"] + networks: [data] + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 3s + timeout: 2s + retries: 20 + deploy: + resources: + limits: + cpus: "0.5" + memory: 192M + + migrate: + build: . + command: ["python", "-m", "scripts.migrate"] + environment: &database_env + DATABASE_HOST: postgres + DATABASE_NAME: messenger + DATABASE_USER: messenger + DATABASE_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + networks: [data] + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api: + build: . + environment: + <<: *database_env + REDIS_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DB_POOL_SIZE: ${DB_POOL_SIZE:-8} + networks: [front, data] + depends_on: + migrate: + condition: service_completed_successfully + redis: + condition: service_healthy + restart: unless-stopped + stop_grace_period: 15s + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).close()"] + interval: 2s + timeout: 3s + start_period: 5s + retries: 2 + deploy: + replicas: ${API_REPLICAS:-2} + resources: + limits: + cpus: "0.75" + memory: 256M + + lb: + image: nginx:1.27.5-alpine + volumes: + - ./infra/nginx.conf:/etc/nginx/nginx.conf:ro + networks: [front] + ports: + - "127.0.0.1:${APP_PORT:-8080}:8080" + depends_on: + api: + condition: service_healthy + restart: unless-stopped + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/health/ready"] + interval: 3s + timeout: 3s + retries: 3 + deploy: + resources: + limits: + cpus: "0.5" + memory: 128M + +networks: + front: + data: + internal: true + +volumes: + postgres_data: diff --git a/infra/nginx.conf b/infra/nginx.conf new file mode 100644 index 00000000..9aa22f18 --- /dev/null +++ b/infra/nginx.conf @@ -0,0 +1,21 @@ +events { worker_connections 1024; } +http { + access_log off; + resolver 127.0.0.11 valid=1s ipv6=off; + server { + listen 8080; + client_max_body_size 16k; + proxy_connect_timeout 1s; + proxy_read_timeout 5s; + proxy_send_timeout 5s; + proxy_next_upstream error timeout http_502 http_503; + proxy_next_upstream_tries 2; + location / { + set $api http://api:8080; + proxy_pass $api; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Request-Id $request_id; + } + } +} diff --git a/infra/swarm-app.yaml b/infra/swarm-app.yaml new file mode 100644 index 00000000..4149471c --- /dev/null +++ b/infra/swarm-app.yaml @@ -0,0 +1,66 @@ +version: "3.8" +services: + api: + image: lab3-api:local + environment: + DATABASE_HOST: lab3data_postgres + DATABASE_NAME: messenger + DATABASE_USER: messenger + DATABASE_PASSWORD_FILE: /run/secrets/lab3_db_password + REDIS_URL: redis://lab3data_redis:6379/0 + SESSION_TTL_SECONDS: "3600" + DB_POOL_SIZE: "8" + secrets: [lab3_db_password] + networks: [data] + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).close()"] + interval: 2s + timeout: 3s + retries: 2 + deploy: + replicas: 2 + placement: + constraints: [node.labels.lab3_compute == true] + update_config: + parallelism: 1 + delay: 3s + order: start-first + failure_action: rollback + rollback_config: + parallelism: 1 + order: start-first + restart_policy: + condition: on-failure + resources: + limits: + cpus: "0.75" + memory: 256M + lb: + image: nginx:1.27.5-alpine + configs: + - source: lab3_nginx_conf + target: /etc/nginx/nginx.conf + networks: [data] + ports: + - target: 8080 + published: 8080 + protocol: tcp + mode: host + deploy: + replicas: 1 + placement: + constraints: [node.labels.lab3_storage == true] + resources: + limits: + cpus: "0.5" + memory: 128M +networks: + data: + external: true + name: lab3data_data +secrets: + lab3_db_password: + external: true +configs: + lab3_nginx_conf: + external: true diff --git a/infra/swarm-data.yaml b/infra/swarm-data.yaml new file mode 100644 index 00000000..d9e3979d --- /dev/null +++ b/infra/swarm-data.yaml @@ -0,0 +1,41 @@ +version: "3.8" +services: + postgres: + image: postgres:16.8-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/lab3_db_password + secrets: [lab3_db_password] + volumes: + - postgres_data:/var/lib/postgresql/data + networks: [data] + deploy: + replicas: 1 + placement: + constraints: [node.labels.lab3_storage == true] + resources: + limits: + cpus: "1.0" + memory: 512M + redis: + image: redis:7.4.2-alpine + command: ["redis-server", "--save", "", "--appendonly", "no", "--maxmemory", "128mb", "--maxmemory-policy", "allkeys-lru"] + networks: [data] + deploy: + replicas: 1 + placement: + constraints: [node.labels.lab3_storage == true] + resources: + limits: + cpus: "0.5" + memory: 192M +networks: + data: + driver: overlay + attachable: true +volumes: + postgres_data: +secrets: + lab3_db_password: + external: true diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..2cdfbf05 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,38 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username varchar(32) NOT NULL UNIQUE, + display_name varchar(100) NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT username_format CHECK (username ~ '^[a-z0-9_]{3,32}$') +); +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title varchar(100) NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats(id), + user_id uuid NOT NULL REFERENCES users(id), + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); +CREATE INDEX chats_order_idx ON chats (created_at, id); +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id), + sender_id uuid NOT NULL REFERENCES users(id), + text varchar(4000) NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); +CREATE TABLE chat_versions ( + chat_id uuid PRIMARY KEY REFERENCES chats(id), + version bigint NOT NULL DEFAULT 0 +); +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id), + expires_at timestamptz NOT NULL +); +CREATE INDEX sessions_expiry_idx ON sessions (expires_at); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..9775cce7 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,10 @@ +CREATE TABLE message_idempotency ( + user_id uuid NOT NULL REFERENCES users(id), + chat_id uuid NOT NULL REFERENCES chats(id), + key varchar(128) NOT NULL, + body_hash bytea NOT NULL, + message_id uuid UNIQUE REFERENCES messages(id), + expires_at timestamptz NOT NULL, + PRIMARY KEY (user_id, chat_id, key) +); +CREATE INDEX message_idempotency_expiry_idx ON message_idempotency (expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..1dc75f74 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +fastapi==0.115.12 +uvicorn==0.34.2 +psycopg[binary,pool]==3.2.6 +redis==5.2.1 diff --git a/scripts/lint.py b/scripts/lint.py new file mode 100644 index 00000000..89935e33 --- /dev/null +++ b/scripts/lint.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +"""Offline lint for this small Python project: syntax, whitespace, unused imports.""" + +import ast +from pathlib import Path +import sys + + +ROOT = Path(__file__).resolve().parents[1] +FILES = [ROOT / "app/main.py", ROOT / "scripts/migrate.py", ROOT / "scripts/lint.py"] + + +def check(path): + source = path.read_text() + issues = [] + try: + tree = ast.parse(source, filename=str(path)) + except SyntaxError as error: + return [f"{path}:{error.lineno}: {error.msg}"] + used = {node.id for node in ast.walk(tree) if isinstance(node, ast.Name)} + for node in ast.walk(tree): + if isinstance(node, ast.Import): + imports = [(item.asname or item.name.split(".")[0], node.lineno) for item in node.names] + elif isinstance(node, ast.ImportFrom): + imports = [(item.asname or item.name, node.lineno) for item in node.names] + else: + continue + for name, line in imports: + if name not in used: + issues.append(f"{path}:{line}: unused import {name}") + for number, line in enumerate(source.splitlines(), 1): + if line.rstrip() != line: + issues.append(f"{path}:{number}: trailing whitespace") + if "\t" in line: + issues.append(f"{path}:{number}: tab character") + return issues + + +def main(): + issues = [issue for path in FILES for issue in check(path)] + if issues: + print("\n".join(issues)) + return 1 + print(f"PASS: lint ({len(FILES)} Python files)") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/migrate.py b/scripts/migrate.py new file mode 100644 index 00000000..c644e75f --- /dev/null +++ b/scripts/migrate.py @@ -0,0 +1,16 @@ +"""Run schema changes once before starting API replicas.""" + +from app.main import migrate, pool + + +def main(): + pool.open() + try: + pool.wait(timeout=20) + migrate() + finally: + pool.close() + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..1522bf0e --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart postgres redis api lb >/dev/null diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..2b8fe9fa --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,12 @@ +#!/bin/sh +set -eu +: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}" +case "$TARGET_INSTANCE_ID" in + *[!a-fA-F0-9]*|'') echo "Invalid instance id" >&2; exit 2 ;; +esac +service=$(docker inspect --format '{{ index .Config.Labels "com.docker.compose.service" }}' "$TARGET_INSTANCE_ID") +if [ "$service" != api ]; then + echo "Target is not a Compose API replica" >&2 + exit 2 +fi +docker stop -t 1 "$TARGET_INSTANCE_ID" >/dev/null -- 2.54.0 From 3a3302c5b4b7e52600a3193a1a3bc73894026f0b Mon Sep 17 00:00:00 2001 From: "yurtaev.va" Date: Fri, 23 Oct 2026 19:03:42 +0300 Subject: [PATCH 2/3] lab3: tiny fix --- Makefile | 1 + REPORT.md | 96 +++++++++++++++++++++++------- evidence/node_failover.json | 20 +++++++ evidence/swarm_load.json | 17 ++++++ evidence/swarm_rolling_load.json | 17 ++++++ evidence/swarm_rolling_stdout.txt | 17 ++++++ evidence/swarm_rolling_update.txt | 90 ++++++++++++++++++++++++++++ evidence/swarm_stats.txt | 3 + infra/swarm-app.yaml | 2 + scripts/lint.py | 2 +- scripts/swarm-lab.sh | 78 ++++++++++++++++++++++++ tests/node_failover.py | 99 +++++++++++++++++++++++++++++++ 12 files changed, 418 insertions(+), 24 deletions(-) create mode 100644 evidence/node_failover.json create mode 100644 evidence/swarm_load.json create mode 100644 evidence/swarm_rolling_load.json create mode 100644 evidence/swarm_rolling_stdout.txt create mode 100644 evidence/swarm_rolling_update.txt create mode 100644 evidence/swarm_stats.txt create mode 100755 scripts/swarm-lab.sh create mode 100644 tests/node_failover.py diff --git a/Makefile b/Makefile index f671ce5e..e81b368a 100644 --- a/Makefile +++ b/Makefile @@ -17,6 +17,7 @@ validate: lint: $(PYTHON) scripts/lint.py + sh -n scripts/restart.sh scripts/stop-one.sh scripts/swarm-lab.sh test: $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/REPORT.md b/REPORT.md index c2679005..e165a8ef 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,87 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +Автор: Юртаев (группа не указана). Цель: **5, трек 2 — отказ узла**. Commit/PR не создавались. Код API перенесён из лабораторной 2 и доработан с помощью Codex. Python 3.12.10, FastAPI 0.115.12, psycopg 3.2.6, Redis 5.2.1, PostgreSQL 16.8, Nginx 1.27.5, Docker 29.3.0 (вложенные daemon 29.3.1). Изучены README, контракт и публичные тесты этого репозитория, исходники lab2, Docker Compose и Swarm CLI. -## Запуск из чистого clone +## Запуск Compose из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Проверено 23.10.2026 на Apple M4, 16 GiB RAM; Docker Desktop выделял 7.653 GiB. Достаточно Docker Engine с Compose, Python 3.9+ и свободного порта 8080. Тестовые данные синтетические, HTTP слушает только `127.0.0.1`. -## Архитектура и решения +```sh +cp .env.example .env +# Заменить POSTGRES_PASSWORD в .env на локальный случайный пароль. +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait +make lint check test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +docker compose --env-file .env start api # восстановить остановленную реплику +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +`migrate` — отдельный одноразовый сервис: он завершается до старта API. Миграции повторно запускаются без дублирования таблиц; транзакционная advisory lock защищает от случайного параллельного оператора. Для остановки без удаления данных: `docker compose --env-file .env down`. Намеренный сброс синтетических данных: `docker compose --env-file .env down -v`. `.env` и volumes исключены из Git. -## Доказательства критериев +## Архитектура и корректность -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +```text +localhost:8080 → Nginx → API × 2 → PostgreSQL (истина: users, sessions, chats, messages, idempotency) + ↘ Redis (только необязательный кэш истории) +``` -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +API не публикует порт на хост и не хранит сессии локально. Nginx использует Docker DNS с TTL 1 с, без sticky session; процесс обозначается `X-Instance-Id` (Docker hostname/container ID). API и Redis имеют лимиты 0.75 CPU/256 MiB и 0.5 CPU/192 MiB; PostgreSQL — 1 CPU/512 MiB; LB — 0.5 CPU/128 MiB. `front` доступен LB и API, `data` — API, PostgreSQL и Redis. Пароль учебной БД задаётся в локальном `.env`; в Swarm передаётся Docker secret. Секрет не включён в образ или отчёт. -## Эксперименты и отказы +Сессии, сообщения и версия истории находятся в PostgreSQL. Redis хранит только страницы с TTL 30 с. Версия чата повышается в той же транзакции, что вставляет сообщение; после COMMIT следующая реплика читает новую версию и не отдаёт старую страницу. При отказе Redis чтение идёт из PostgreSQL. `/health/live` проверяет процесс; `/health/ready` делает SQL `SELECT 1`, потому что PostgreSQL обязателен для сессий и синхронного API. PostgreSQL недоступен — 503, Redis недоступен — API остаётся готовым. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Для сообщений обязателен `Idempotency-Key`. Первичный ключ `(user_id, chat_id, key)` в PostgreSQL сериализует параллельные запросы всех реплик. В одной транзакции фиксируются резервирование ключа, сообщение, ссылка на него и новая версия истории. Повтор с тем же текстом в течение 24 часов получает исходные `201` и Message; другой текст — 409. Истёкшую запись удаляют при следующем применении этого ключа. Проверка сессии и членства выполняется до повторного ответа. Неподтверждённый POST можно повторить с тем же ключом. Отсутствие отдельного фонового удаления истёкших ключей означает рост таблицы при большом числе одноразовых ключей; эксплуатационная очистка — следующий шаг. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +API healthcheck: каждые 2 с, timeout 3 с, 2 неудачи. Nginx connect timeout 1 с, read/send timeout 5 с, DNS cache 1 с, один повтор upstream при сетевой ошибке или 502/503. Uvicorn обрабатывает SIGTERM и получает 15 с на завершение запросов; readiness сбрасывается при shutdown. Для остановленного процесса наблюдавшееся восстановление новых записей — 1.70–1.95 с. Верхняя граница при сетевом зависании зависит от таймаута запроса и Docker DNS; активной проверки каждого backend в Nginx нет. -## Ограничения и следующие шаги +Миграция 002 добавляет таблицу и индекс, не меняя старые поля: её можно выполнить при работающей версии lab2. Однако в период смешанных lab2/lab3 API старый процесс не обеспечивает идемпотентность, поэтому клиентов с новым контрактом переключают только после завершения обновления. Swarm `update_config` заменяет по одной реплике (`start-first`, 3 с пауза), с rollback при неудаче. Проверка обновления ниже принудительно пересоздавала тот же образ; переход между разными версиями приложения не измерялся. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +## Публичные проверки уровней 3–4 + +| Критерий | Команда | Наблюдение | +| --- | --- | --- | +| Контракт и линт | `make lint check` | PASS | +| Smoke через LB | `make test` | PASS: оба `X-Instance-Id`, Basic/Bearer, доступ, пагинация, ключ | +| Полный рестарт без удаления volume | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: старый токен и сообщение после рестарта API, PostgreSQL, Redis, LB | +| Отказ API-2 | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 2 реплики до отказа; 122 записи/15 с ≈8.13 RPS, 0 ошибок, первая запись через 1.946 с | +| Отказ API-1 после восстановления API-2 | та же команда | 122 записи/15 с ≈8.13 RPS, 0 ошибок, первая запись через 1.704 с; остановлен `api-1` | +| Конкурентный ключ | `python3 tests/node_failover.py` | 16 одновременных POST через LB вернули одно Message | +| Rolling update под нагрузкой | `scripts/swarm-lab.sh rolling-update` одновременно с `tests/load.py` | 10 791 подтверждённая запись/30.041 с, 359.214 RPS, 0 ошибок; p50/p95/p99 = 8.830/22.727/64.266 мс | + +Скрипт `stop-one.sh` сопоставляет `TARGET_INSTANCE_ID` с Docker container ID и проверяет label сервиса `api`; он останавливает именно выбранный тестом процесс. После сценария `docker compose ps -a api` показывает остановленную реплику. При первом прогоне остановилась `api-2`, затем она была восстановлена; при втором — `api-1` (ID `0c6d23164d9a`). `restart.sh` перезапускает все используемые сервисы без `down -v`. + +## Трек 2: отказ узла + +**Гипотеза:** если на двух worker работают взаимозаменяемые API, потеря одного Docker-узла оставит доступ к подтверждённым данным через оставшийся API, а Swarm разместит новую задачу API на живом worker. PostgreSQL и LB намеренно закреплены на manager: их отказ этот стенд не переживает. + +Воспроизводимый локальный эксперимент использует три независимых Docker daemon в привилегированных контейнерах Docker-in-Docker, соединённых одной сетью. Это **логические узлы на одном физическом Mac**, поэтому не доказывает устойчивость к потере самого Mac или Docker Desktop. Swarm manager хранит PostgreSQL volume и запускает LB/Redis; два worker первоначально держат по одному API. Образ `lab3-api:local` загружается в каждый daemon; в реальных отдельных машинах нужен общий registry с закреплённым digest и защищённые сетевые каналы. Внешняя точка входа вложенного стенда — `127.0.0.1:18080`. + +```sh +scripts/swarm-lab.sh up +# Дождаться ответа /health/ready; затем: +make test BASE_URL=http://127.0.0.1:18080 +python3 tests/node_failover.py --worker lab3-worker1 --output evidence/node_failover.json +scripts/swarm-lab.sh status +scripts/swarm-lab.sh recover-node lab3-worker1 +# Остановка и удаление временного синтетического кластера: +scripts/swarm-lab.sh down +``` + +`node_failover.py` сначала создаёт чат и сессию, проверяет два разных instance ID, отправляет 16 конкурентных повторов одного ключа, затем выполняет `docker stop` worker1. До появления двух API-задач на оставшемся worker он непрерывно отправляет POST с новым ключом и после каждого успеха выполняет GET истории другим участником; неопределённый POST повторялся бы с тем же ключом. В конце проверяются все подтверждённые сообщения и отсутствие дубля. Один запуск дал: + +| Показатель | Значение | +| --- | ---: | +| Размещение до / после | worker1 + worker2 / worker2 + worker2 | +| Время появления новой задачи API | 20.054 с | +| Успешные записи / ошибки | 96 / 0 | +| Первая запись после остановки worker | 0.020 с | +| p50 / p95 записи | 14.586 / 22.945 мс | +| Сохранность подтверждённых данных | подтверждена чтением через оставшийся узел | + +Сырые агрегаты: [отказ узла](evidence/node_failover.json), [rolling update](evidence/swarm_rolling_load.json), [отдельная нагрузка](evidence/swarm_load.json), [снимок ресурсов во время отдельной нагрузки](evidence/swarm_stats.txt). Во время отдельного 15-секундного прогона было 4513 успехов, 0 ошибок, 300.358 RPS. Однократный `docker stats` показал: manager 61.49% CPU / 272.4 MiB, worker1 70.05% / 132.1 MiB, worker2 85.95% / 166.9 MiB. Это расход целых вложенных узлов, включая daemon, а не только приложения. + +Защищённая зависимость здесь — **API worker**: его задача реально исчезла с остановленного daemon и была создана на worker2; сессия и сообщения остались доступны из PostgreSQL на manager. Redis — необязательный кэш, его данные не требуются для сохранности. Единичные PostgreSQL, локальный volume manager, единственный LB и сам manager остаются SPOF. Утрата manager/его volume не выдерживается и не заявляется как защищённый сценарий. Для устойчивости к ним потребуются внешний/реплицированный PostgreSQL с проверенным failover, репликация хранения и несколько LB с переключаемой внешней точкой входа. + +## Ограничения измерений + +Все результаты получены на одном ноутбуке и при synthetic closed-loop нагрузке. Клиент ограничивает RPS и имеет coordinated omission; p50/p95/p99 охватывают только успешные запросы. Срез CPU/RAM один и не отражает пики. Во время отказа узла сервис продолжал отвечать за счёт второй реплики, хотя восстановление полного числа задач заняло 20 с. В Swarm не проверялись физическое отключение машины, потеря manager, отказ PostgreSQL/диска и обновление между версиями. Локальный DinD использует привилегированные контейнеры только для учебного эксперимента. diff --git a/evidence/node_failover.json b/evidence/node_failover.json new file mode 100644 index 00000000..ff60926b --- /dev/null +++ b/evidence/node_failover.json @@ -0,0 +1,20 @@ +{ + "before_nodes": [ + "lab3-worker1", + "lab3-worker2" + ], + "after_nodes": [ + "lab3-worker2", + "lab3-worker2" + ], + "before_instance_count": 2, + "concurrent_replays": 16, + "concurrent_message_count": 1, + "successful_writes": 96, + "failed_attempts": 0, + "first_success_seconds": 0.02, + "replacement_running_seconds": 20.054, + "confirmed_messages_preserved": true, + "latency_p50_ms": 14.586, + "latency_p95_ms": 22.945 +} diff --git a/evidence/swarm_load.json b/evidence/swarm_load.json new file mode 100644 index 00000000..d01b6311 --- /dev/null +++ b/evidence/swarm_load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.025, + "concurrency": 4, + "successful_requests": 4513, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 300.358, + "successful_latency_ms": { + "p50": 9.415, + "p95": 35.526, + "p99": 77.236 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/swarm_rolling_load.json b/evidence/swarm_rolling_load.json new file mode 100644 index 00000000..1f40fc10 --- /dev/null +++ b/evidence/swarm_rolling_load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.041, + "concurrency": 4, + "successful_requests": 10791, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 359.214, + "successful_latency_ms": { + "p50": 8.83, + "p95": 22.727, + "p99": 64.266 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/swarm_rolling_stdout.txt b/evidence/swarm_rolling_stdout.txt new file mode 100644 index 00000000..1f40fc10 --- /dev/null +++ b/evidence/swarm_rolling_stdout.txt @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.041, + "concurrency": 4, + "successful_requests": 10791, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 359.214, + "successful_latency_ms": { + "p50": 8.83, + "p95": 22.727, + "p99": 64.266 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/swarm_rolling_update.txt b/evidence/swarm_rolling_update.txt new file mode 100644 index 00000000..76beb7e2 --- /dev/null +++ b/evidence/swarm_rolling_update.txt @@ -0,0 +1,90 @@ +lab3app_api +overall progress: 0 out of 2 tasks +1/2: +2/2: +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 0 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 1 out of 2 tasks +overall progress: 2 out of 2 tasks +verify: Waiting 5 seconds to verify that tasks are stable... +verify: Waiting 5 seconds to verify that tasks are stable... +verify: Waiting 5 seconds to verify that tasks are stable... +verify: Waiting 5 seconds to verify that tasks are stable... +verify: Waiting 5 seconds to verify that tasks are stable... +verify: Waiting 4 seconds to verify that tasks are stable... +verify: Waiting 4 seconds to verify that tasks are stable... +verify: Waiting 4 seconds to verify that tasks are stable... +verify: Waiting 4 seconds to verify that tasks are stable... +verify: Waiting 4 seconds to verify that tasks are stable... +verify: Waiting 3 seconds to verify that tasks are stable... +verify: Waiting 3 seconds to verify that tasks are stable... +verify: Waiting 3 seconds to verify that tasks are stable... +verify: Waiting 3 seconds to verify that tasks are stable... +verify: Waiting 3 seconds to verify that tasks are stable... +verify: Waiting 2 seconds to verify that tasks are stable... +verify: Waiting 2 seconds to verify that tasks are stable... +verify: Waiting 2 seconds to verify that tasks are stable... +verify: Waiting 2 seconds to verify that tasks are stable... +verify: Waiting 2 seconds to verify that tasks are stable... +verify: Waiting 1 seconds to verify that tasks are stable... +verify: Waiting 1 seconds to verify that tasks are stable... +verify: Waiting 1 seconds to verify that tasks are stable... +verify: Waiting 1 seconds to verify that tasks are stable... +verify: Waiting 1 seconds to verify that tasks are stable... +verify: Service lab3app_api converged diff --git a/evidence/swarm_stats.txt b/evidence/swarm_stats.txt new file mode 100644 index 00000000..a603b211 --- /dev/null +++ b/evidence/swarm_stats.txt @@ -0,0 +1,3 @@ +lab3-manager 61.49% 272.4MiB / 7.653GiB +lab3-worker1 70.05% 132.1MiB / 7.653GiB +lab3-worker2 85.95% 166.9MiB / 7.653GiB diff --git a/infra/swarm-app.yaml b/infra/swarm-app.yaml index 4149471c..62d54d88 100644 --- a/infra/swarm-app.yaml +++ b/infra/swarm-app.yaml @@ -21,6 +21,8 @@ services: replicas: 2 placement: constraints: [node.labels.lab3_compute == true] + preferences: + - spread: node.hostname update_config: parallelism: 1 delay: 3s diff --git a/scripts/lint.py b/scripts/lint.py index 89935e33..42c7f894 100644 --- a/scripts/lint.py +++ b/scripts/lint.py @@ -7,7 +7,7 @@ import sys ROOT = Path(__file__).resolve().parents[1] -FILES = [ROOT / "app/main.py", ROOT / "scripts/migrate.py", ROOT / "scripts/lint.py"] +FILES = [ROOT / "app/main.py", ROOT / "scripts/migrate.py", ROOT / "scripts/lint.py", ROOT / "tests/node_failover.py"] def check(path): diff --git a/scripts/swarm-lab.sh b/scripts/swarm-lab.sh new file mode 100755 index 00000000..f814b2e0 --- /dev/null +++ b/scripts/swarm-lab.sh @@ -0,0 +1,78 @@ +#!/bin/sh +# Local three-daemon Swarm for the node-loss experiment. All data are synthetic. +set -eu +cd "$(dirname "$0")/.." + +manager() { docker exec lab3-manager docker "$@"; } + +case "${1:-}" in + up) + test -f .env || { echo "Create .env first" >&2; exit 2; } + docker network create lab3-nodes >/dev/null + docker run -d --privileged --network lab3-nodes --name lab3-manager --hostname lab3-manager -p 127.0.0.1:18080:8080 docker:29.3-dind --host=unix:///var/run/docker.sock >/dev/null + for node in lab3-worker1 lab3-worker2; do + docker run -d --privileged --network lab3-nodes --name "$node" --hostname "$node" docker:29.3-dind --host=unix:///var/run/docker.sock >/dev/null + done + for node in lab3-manager lab3-worker1 lab3-worker2; do + count=0 + until docker exec "$node" docker info >/dev/null 2>&1; do + count=$((count + 1)) + test "$count" -lt 60 || { echo "$node daemon unavailable" >&2; exit 1; } + sleep 1 + done + done + manager_ip=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' lab3-manager) + manager swarm init --advertise-addr "$manager_ip" >/dev/null + join_token=$(manager swarm join-token -q worker) + for node in lab3-worker1 lab3-worker2; do + docker exec "$node" docker swarm join --token "$join_token" "$manager_ip:2377" >/dev/null + manager node update --label-add lab3_compute=true "$node" >/dev/null + done + manager node update --label-add lab3_storage=true lab3-manager >/dev/null + docker build -q -t lab3-api:local . >/dev/null + for node in lab3-manager lab3-worker1 lab3-worker2; do + docker save lab3-api:local | docker exec -i "$node" docker load >/dev/null + done + python3 -c 'from pathlib import Path; import sys; lines=Path(".env").read_text().splitlines(); values=[line.split("=",1)[1] for line in lines if line.startswith("POSTGRES_PASSWORD=")]; sys.stdout.write(values[-1])' | docker exec -i lab3-manager docker secret create lab3_db_password - >/dev/null + docker exec -i lab3-manager docker config create lab3_nginx_conf - < infra/nginx.conf >/dev/null + docker exec -i lab3-manager docker stack deploy --resolve-image never -c - lab3data < infra/swarm-data.yaml + count=0 + until manager service ls --format '{{.Name}} {{.Replicas}}' | grep -q '^lab3data_postgres 1/1$'; do + count=$((count + 1)) + test "$count" -lt 120 || { manager service ps lab3data_postgres; exit 1; } + sleep 1 + done + manager service create --detach=true --name lab3-migrate --network lab3data_data --secret lab3_db_password --env DATABASE_HOST=lab3data_postgres --env DATABASE_NAME=messenger --env DATABASE_USER=messenger --env DATABASE_PASSWORD_FILE=/run/secrets/lab3_db_password --restart-condition on-failure --restart-max-attempts 10 lab3-api:local python -m scripts.migrate >/dev/null + count=0 + until manager service ps --format '{{.CurrentState}}' lab3-migrate | head -1 | grep -q '^Complete'; do + count=$((count + 1)) + test "$count" -lt 90 || { manager service ps lab3-migrate; exit 1; } + sleep 1 + done + docker exec -i lab3-manager docker stack deploy --resolve-image never -c - lab3app < infra/swarm-app.yaml + echo "Swarm endpoint: http://127.0.0.1:18080 (wait for /health/ready)" + ;; + status) + manager node ls + manager service ls + manager service ps lab3app_api + ;; + fail-node) + case "${2:-}" in lab3-worker1|lab3-worker2) docker stop -t 1 "$2" >/dev/null ;; *) echo "Choose lab3-worker1 or lab3-worker2" >&2; exit 2 ;; esac + ;; + recover-node) + case "${2:-}" in lab3-worker1|lab3-worker2) docker start "$2" >/dev/null ;; *) echo "Choose lab3-worker1 or lab3-worker2" >&2; exit 2 ;; esac + ;; + rolling-update) + manager service update --force --update-parallelism 1 --update-order start-first lab3app_api + ;; + down) + echo "Removing the ephemeral synthetic Swarm cluster and its data." + docker rm -f lab3-manager lab3-worker1 lab3-worker2 >/dev/null + docker network rm lab3-nodes >/dev/null + ;; + *) + echo "Usage: $0 up|status|fail-node WORKER|recover-node WORKER|rolling-update|down" >&2 + exit 2 + ;; +esac diff --git a/tests/node_failover.py b/tests/node_failover.py new file mode 100644 index 00000000..8bb50657 --- /dev/null +++ b/tests/node_failover.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python3 +"""Exercise a real Swarm worker loss while reading and writing through the LB.""" + +import argparse +from concurrent.futures import ThreadPoolExecutor +import json +from pathlib import Path +import statistics +import subprocess +import time +import uuid + +from client import Client, Failure + + +def tasks(): + result = subprocess.check_output([ + "docker", "exec", "lab3-manager", "docker", "service", "ps", + "--filter", "desired-state=running", "--format", "{{.Node}} {{.CurrentState}}", + "lab3app_api", + ], text=True) + return [line.split()[0] for line in result.splitlines() if "Running" in line] + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--base-url", default="http://127.0.0.1:18080") + parser.add_argument("--worker", choices=["lab3-worker1", "lab3-worker2"], default="lab3-worker1") + parser.add_argument("--output", default="evidence/node_failover.json") + args = parser.parse_args() + client = Client(args.base_url, timeout=2) + alice, bob, _, chat = client.bootstrap() + before = tasks() + assert len(before) == 2 and args.worker in before, before + instances = { + client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"] + for _ in range(40) + } + assert len(instances) == 2, instances + + key = uuid.uuid4().hex + body = "concurrent " + key + with ThreadPoolExecutor(max_workers=16) as executor: + results = list(executor.map(lambda _: client.message(alice, chat, body, key=key)["json"], range(16))) + assert all(item == results[0] for item in results) + + subprocess.run(["docker", "stop", "-t", "1", args.worker], check=True, stdout=subprocess.DEVNULL) + start = time.monotonic() + successes = [] + errors = 0 + latencies = [] + moved_at = None + first_success = None + pending_key = uuid.uuid4().hex + pending_text = "node-fail " + pending_key + while time.monotonic() - start < 75: + try: + response = client.message(alice, chat, pending_text, key=pending_key) + successes.append(response["json"]) + latencies.append(response["elapsed"] * 1000) + if first_success is None: + first_success = time.monotonic() - start + client.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=1", actor=bob, schema="MessagePage") + pending_key = uuid.uuid4().hex + pending_text = "node-fail " + pending_key + except Failure: + errors += 1 + current = tasks() + if len(current) == 2 and args.worker not in current and moved_at is None: + moved_at = time.monotonic() - start + if moved_at is not None and time.monotonic() - start > moved_at + 5: + break + time.sleep(0.15) + assert moved_at is not None, tasks() + assert successes, "no writes during node failure" + page = client.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", actor=bob, schema="MessagePage")["json"] + seen = {item["id"] for item in page["items"]} + assert results[0]["id"] in seen and all(item["id"] in seen for item in successes) + assert sum(item["text"] == body for item in page["items"]) == 1 + report = { + "before_nodes": before, + "after_nodes": tasks(), + "before_instance_count": len(instances), + "concurrent_replays": len(results), + "concurrent_message_count": 1, + "successful_writes": len(successes), + "failed_attempts": errors, + "first_success_seconds": round(first_success, 3), + "replacement_running_seconds": round(moved_at, 3), + "confirmed_messages_preserved": True, + "latency_p50_ms": round(statistics.median(latencies), 3), + "latency_p95_ms": round(sorted(latencies)[int(0.95 * (len(latencies) - 1))], 3), + } + Path(args.output).write_text(json.dumps(report, indent=2) + "\n") + print(json.dumps(report, indent=2)) + + +if __name__ == "__main__": + main() -- 2.54.0 From 088961a4332c4732c27328598f484cf7197f2d5f Mon Sep 17 00:00:00 2001 From: "yurtaev.va" Date: Fri, 23 Oct 2026 19:29:40 +0300 Subject: [PATCH 3/3] lab3: second tiny fix --- .github/pull_request_template.md | 24 +++--- REPORT.md | 33 ++++---- app/main.py | 2 +- compose.yaml | 9 ++- evidence/README.md | 9 ++- evidence/history_explain.txt | 11 +++ evidence/node_failover.json | 52 +++++++++---- evidence/readiness_failover.json | 10 +++ evidence/swarm_load.json | 12 +-- evidence/swarm_rolling_load.json | 12 +-- evidence/swarm_rolling_stdout.txt | 17 ---- evidence/swarm_rolling_update.txt | 4 - evidence/swarm_stats.txt | 6 +- infra/README.md | 8 +- infra/haproxy-compose.cfg | 27 +++++++ infra/haproxy-swarm.cfg | 27 +++++++ infra/nginx.conf | 21 ----- infra/swarm-app.yaml | 8 +- scripts/history_explain.py | 50 ++++++++++++ scripts/lint.py | 2 +- scripts/swarm-lab.sh | 6 +- tests/lb_readiness.py | 60 +++++++++++++++ tests/level4.py | 124 ++++++++++++++++++++++++++++++ tests/node_failover.py | 77 ++++++++++++++----- 24 files changed, 477 insertions(+), 134 deletions(-) create mode 100644 evidence/history_explain.txt create mode 100644 evidence/readiness_failover.json delete mode 100644 evidence/swarm_rolling_stdout.txt create mode 100644 infra/haproxy-compose.cfg create mode 100644 infra/haproxy-swarm.cfg delete mode 100644 infra/nginx.conf create mode 100644 scripts/history_explain.py create mode 100644 tests/lb_readiness.py create mode 100644 tests/level4.py diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index e6e63eb2..221659b7 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,14 @@ ## Лабораторная 3 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор: Юртаев (группа не указана). Целевая оценка: **5**, трек 2 «Отказ узла». -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Перенесён API лабораторной 2. Добавлены общая идемпотентность сообщений в PostgreSQL, две API-реплики за HAProxy с readiness checks, отдельные миграции, hooks рестарта/отказа и трёхузловой учебный Swarm. Инструкция запуска и измерения: [REPORT.md](../REPORT.md). -- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. -- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +Проверки: `make lint check test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`, `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, `python3 tests/lb_readiness.py`, `python3 tests/level4.py`, `python3 tests/node_failover.py`, `python3 scripts/history_explain.py`. Все прошли на локальном синтетическом стенде; агрегаты сохранены в `evidence/`. + +Ограничения: узлы Swarm — независимые Docker daemon на одном физическом Mac. PostgreSQL, его volume, manager и LB не реплицированы; их отказ стенд не переживает. HTTP доступен только на loopback для учебных данных. Секреты и токены в Git не сохраняются. + +- [x] Обязательный API и возможности lab2 сохранены. +- [x] Контракт и публичные тесты не ослаблены. +- [x] Проверены рестарт, обе API-реплики, отказ worker и rolling update. +- [x] README задания сохранён, отчёт содержит команды и ограничения. diff --git a/REPORT.md b/REPORT.md index e165a8ef..5f0360c0 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,6 +1,6 @@ # Отчёт — лабораторная 3 -Автор: Юртаев (группа не указана). Цель: **5, трек 2 — отказ узла**. Commit/PR не создавались. Код API перенесён из лабораторной 2 и доработан с помощью Codex. Python 3.12.10, FastAPI 0.115.12, psycopg 3.2.6, Redis 5.2.1, PostgreSQL 16.8, Nginx 1.27.5, Docker 29.3.0 (вложенные daemon 29.3.1). Изучены README, контракт и публичные тесты этого репозитория, исходники lab2, Docker Compose и Swarm CLI. +Автор: Юртаев (группа не указана). Цель: **5, трек 2 — отказ узла**. Локальные commits `2e23dbe`, `3a3302c`; PR не создавался. Код API перенесён из лабораторной 2 и доработан с помощью Codex. Python 3.12.10, FastAPI 0.115.12, psycopg 3.2.6, Redis 5.2.1, PostgreSQL 16.8, HAProxy 3.2.6, Docker 29.3.0 (вложенные daemon 29.3.1). Изучены README, контракт и публичные тесты этого репозитория, исходники lab2, Docker Compose, Swarm CLI и [документация HAProxy по DNS discovery](https://www.haproxy.com/documentation/haproxy-configuration-tutorials/proxying-essentials/dns-resolution/). ## Запуск Compose из чистого clone @@ -22,17 +22,19 @@ docker compose --env-file .env start api # восстановить остан ## Архитектура и корректность ```text -localhost:8080 → Nginx → API × 2 → PostgreSQL (истина: users, sessions, chats, messages, idempotency) +localhost:8080 → HAProxy → API × 2 → PostgreSQL (истина: users, sessions, chats, messages, idempotency) ↘ Redis (только необязательный кэш истории) ``` -API не публикует порт на хост и не хранит сессии локально. Nginx использует Docker DNS с TTL 1 с, без sticky session; процесс обозначается `X-Instance-Id` (Docker hostname/container ID). API и Redis имеют лимиты 0.75 CPU/256 MiB и 0.5 CPU/192 MiB; PostgreSQL — 1 CPU/512 MiB; LB — 0.5 CPU/128 MiB. `front` доступен LB и API, `data` — API, PostgreSQL и Redis. Пароль учебной БД задаётся в локальном `.env`; в Swarm передаётся Docker secret. Секрет не включён в образ или отчёт. +API не публикует порт на хост и не хранит сессии локально. HAProxy получает адреса реплик через Docker DNS с TTL 1 с, проверяет `/health/ready` каждой и балансирует без sticky session; процесс обозначается `X-Instance-Id` (Docker hostname/container ID). В Compose DNS-имя `api` возвращает адреса контейнеров, в Swarm `tasks.lab3app_api` — адреса задач, минуя VIP. API и Redis имеют лимиты 0.75 CPU/256 MiB и 0.5 CPU/192 MiB; PostgreSQL — 1 CPU/512 MiB; LB — 0.5 CPU/128 MiB; одноразовая миграция — 0.5 CPU/256 MiB. `front` доступен LB и API, `data` — API, PostgreSQL и Redis. Пароль учебной БД задаётся в локальном `.env`; в Swarm передаётся Docker secret. Секрет не включён в образ или отчёт. Сессии, сообщения и версия истории находятся в PostgreSQL. Redis хранит только страницы с TTL 30 с. Версия чата повышается в той же транзакции, что вставляет сообщение; после COMMIT следующая реплика читает новую версию и не отдаёт старую страницу. При отказе Redis чтение идёт из PostgreSQL. `/health/live` проверяет процесс; `/health/ready` делает SQL `SELECT 1`, потому что PostgreSQL обязателен для сессий и синхронного API. PostgreSQL недоступен — 503, Redis недоступен — API остаётся готовым. Для сообщений обязателен `Idempotency-Key`. Первичный ключ `(user_id, chat_id, key)` в PostgreSQL сериализует параллельные запросы всех реплик. В одной транзакции фиксируются резервирование ключа, сообщение, ссылка на него и новая версия истории. Повтор с тем же текстом в течение 24 часов получает исходные `201` и Message; другой текст — 409. Истёкшую запись удаляют при следующем применении этого ключа. Проверка сессии и членства выполняется до повторного ответа. Неподтверждённый POST можно повторить с тем же ключом. Отсутствие отдельного фонового удаления истёкших ключей означает рост таблицы при большом числе одноразовых ключей; эксплуатационная очистка — следующий шаг. -API healthcheck: каждые 2 с, timeout 3 с, 2 неудачи. Nginx connect timeout 1 с, read/send timeout 5 с, DNS cache 1 с, один повтор upstream при сетевой ошибке или 502/503. Uvicorn обрабатывает SIGTERM и получает 15 с на завершение запросов; readiness сбрасывается при shutdown. Для остановленного процесса наблюдавшееся восстановление новых записей — 1.70–1.95 с. Верхняя граница при сетевом зависании зависит от таймаута запроса и Docker DNS; активной проверки каждого backend в Nginx нет. +Контейнерный API healthcheck: каждые 2 с, timeout 3 с, 2 неудачи. HAProxy проверяет каждую реплику раз в 1 с, timeout проверки 1 с, исключает после 2 неудач и возвращает после 2 успехов. Настроенный максимум обнаружения живой unready реплики при обычном планировании — до 4 с (ожидание следующей проверки и две проверки до timeout); обновление адреса DNS добавляет до 1 с. Connect timeout клиентского запроса — 1 с, server/client timeout — 10 с. Uvicorn обрабатывает SIGTERM и получает 15 с на завершение запросов; readiness сбрасывается при shutdown. Отдельный тест разорвал только связь API-1 с БД, оставив процесс живым: HAProxy исключил реплику за 5.435 с **включая** 20 последовательных подтверждающих GET, затем 10 POST прошли через вторую реплику. Во время обнаружения было 2 ошибки. Это измеренный сценарий, а не универсальная жёсткая SLA при произвольной задержке планировщика/сети. + +История сортируется по `(created_at,id)` и использует keyset cursor. При неизменной истории повторов нет; новый элемент после позиции cursor может появиться на следующей странице, а вставка с более ранней позицией может быть пропущена текущим обходом. Snapshot между HTTP-запросами не обещается. Время назначает одна PostgreSQL; `clock_timestamp()` может не соответствовать порядку COMMIT и при переводе часов идти назад. UUID развязывает одинаковые отметки времени, но не превращает сортировку в порядок подтверждения транзакций. На 10 000 синтетических сообщений `EXPLAIN (ANALYZE, BUFFERS)` показал `Index Scan using messages_history_idx`, 101 прочитанная строка, 11 shared hits, 0.074 мс ([сырой план](evidence/history_explain.txt)). Миграция 002 добавляет таблицу и индекс, не меняя старые поля: её можно выполнить при работающей версии lab2. Однако в период смешанных lab2/lab3 API старый процесс не обеспечивает идемпотентность, поэтому клиентов с новым контрактом переключают только после завершения обновления. Swarm `update_config` заменяет по одной реплике (`start-first`, 3 с пауза), с rollback при неудаче. Проверка обновления ниже принудительно пересоздавала тот же образ; переход между разными версиями приложения не измерялся. @@ -41,14 +43,17 @@ API healthcheck: каждые 2 с, timeout 3 с, 2 неудачи. Nginx connec | Критерий | Команда | Наблюдение | | --- | --- | --- | | Контракт и линт | `make lint check` | PASS | -| Smoke через LB | `make test` | PASS: оба `X-Instance-Id`, Basic/Bearer, доступ, пагинация, ключ | +| Smoke через LB | `make test` | PASS: `X-Instance-Id` в ответах, Basic/Bearer, доступ, пагинация, ключ | | Полный рестарт без удаления volume | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: старый токен и сообщение после рестарта API, PostgreSQL, Redis, LB | -| Отказ API-2 | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 2 реплики до отказа; 122 записи/15 с ≈8.13 RPS, 0 ошибок, первая запись через 1.946 с | -| Отказ API-1 после восстановления API-2 | та же команда | 122 записи/15 с ≈8.13 RPS, 0 ошибок, первая запись через 1.704 с; остановлен `api-1` | +| Отказ API-1 | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | 2 реплики до отказа; 109 записей/15 с ≈7.27 RPS, 2 ошибки, первая запись через 2.462 с | +| Отказ API-2 после восстановления API-1 | та же команда | 111 записей/15 с ≈7.40 RPS, 1 ошибка, первая запись через 2.251 с; остановлен `api-2` | +| Живая, но неготовая реплика | `python3 tests/lb_readiness.py` | API-1 потеряла связь с БД; исключена HAProxy за 5.435 с включая 20 подтверждений; 10 POST после исключения успешны | | Конкурентный ключ | `python3 tests/node_failover.py` | 16 одновременных POST через LB вернули одно Message | -| Rolling update под нагрузкой | `scripts/swarm-lab.sh rolling-update` одновременно с `tests/load.py` | 10 791 подтверждённая запись/30.041 с, 359.214 RPS, 0 ошибок; p50/p95/p99 = 8.830/22.727/64.266 мс | +| Унаследованные проверки lab2 уровня 4 | `python3 tests/level4.py` | PASS: гонка username, rollback чата, fallback Redis, 503 при отказе PostgreSQL, expiry сессии | +| Rolling update под нагрузкой | `scripts/swarm-lab.sh rolling-update` одновременно с `tests/load.py` | 7449 подтверждённых записей/30.035 с, 248.009 RPS, 0 ошибок; p50/p95/p99 = 12.897/37.412/73.878 мс | +| Индекс истории lab2 | `python3 scripts/history_explain.py` | 10 000 строк, Index Scan, 11 buffer hits, 0.074 мс | -Скрипт `stop-one.sh` сопоставляет `TARGET_INSTANCE_ID` с Docker container ID и проверяет label сервиса `api`; он останавливает именно выбранный тестом процесс. После сценария `docker compose ps -a api` показывает остановленную реплику. При первом прогоне остановилась `api-2`, затем она была восстановлена; при втором — `api-1` (ID `0c6d23164d9a`). `restart.sh` перезапускает все используемые сервисы без `down -v`. +Скрипт `stop-one.sh` сопоставляет `TARGET_INSTANCE_ID` с Docker container ID и проверяет label сервиса `api`; он останавливает именно выбранный тестом процесс. После сценария `docker compose ps -a api` показывает остановленную реплику. При первом прогоне остановилась `api-1` (ID `d5c6218cf96c`), затем она была восстановлена; при втором — `api-2` (ID `d6788e0998bf`). `restart.sh` перезапускает все используемые сервисы без `down -v`. ## Трек 2: отказ узла @@ -72,13 +77,13 @@ scripts/swarm-lab.sh down | Показатель | Значение | | --- | ---: | | Размещение до / после | worker1 + worker2 / worker2 + worker2 | -| Время появления новой задачи API | 20.054 с | -| Успешные записи / ошибки | 96 / 0 | -| Первая запись после остановки worker | 0.020 с | -| p50 / p95 записи | 14.586 / 22.945 мс | +| Время появления новой задачи API | 20.311 с | +| Успешные записи и чтения / ошибки | 92 POST + 92 GET / 0 | +| Первая запись от начала команды остановки worker | 1.216 с (сама команда заняла 1.199 с) | +| p50 / p95 записи | 13.096 / 16.899 мс | | Сохранность подтверждённых данных | подтверждена чтением через оставшийся узел | -Сырые агрегаты: [отказ узла](evidence/node_failover.json), [rolling update](evidence/swarm_rolling_load.json), [отдельная нагрузка](evidence/swarm_load.json), [снимок ресурсов во время отдельной нагрузки](evidence/swarm_stats.txt). Во время отдельного 15-секундного прогона было 4513 успехов, 0 ошибок, 300.358 RPS. Однократный `docker stats` показал: manager 61.49% CPU / 272.4 MiB, worker1 70.05% / 132.1 MiB, worker2 85.95% / 166.9 MiB. Это расход целых вложенных узлов, включая daemon, а не только приложения. +Сырые агрегаты: [отказ узла](evidence/node_failover.json), [readiness](evidence/readiness_failover.json), [rolling update](evidence/swarm_rolling_load.json), [отдельная нагрузка](evidence/swarm_load.json), [снимок ресурсов во время отдельной нагрузки](evidence/swarm_stats.txt). В `node_failover.json` сохранены task ID и instance ID до и после переноса; 16 конкурентных ответов пришли от обеих исходных реплик. Во время отдельного 15-секундного прогона было 3864 успеха, 0 ошибок, 256.971 RPS. Однократный `docker stats` показал: manager 68.26% CPU / 260.3 MiB, worker1 74.43% / 150.5 MiB, worker2 79.84% / 198.8 MiB. Это расход целых вложенных узлов, включая daemon, а не только приложения. Защищённая зависимость здесь — **API worker**: его задача реально исчезла с остановленного daemon и была создана на worker2; сессия и сообщения остались доступны из PostgreSQL на manager. Redis — необязательный кэш, его данные не требуются для сохранности. Единичные PostgreSQL, локальный volume manager, единственный LB и сам manager остаются SPOF. Утрата manager/его volume не выдерживается и не заявляется как защищённый сценарий. Для устойчивости к ним потребуются внешний/реплицированный PostgreSQL с проверенным failover, репликация хранения и несколько LB с переключаемой внешней точкой входа. diff --git a/app/main.py b/app/main.py index fee71a09..40e3655f 100644 --- a/app/main.py +++ b/app/main.py @@ -333,7 +333,7 @@ async def create_user(request: Request): invalid("Некорректный username") display = text_field(data["display_name"], 100) password = data["password"] - if not isinstance(password, str) or not 12 <= len(password) <= 128: + if not isinstance(password, str) or not password.strip() or not 12 <= len(password) <= 128: invalid("Некорректный пароль") try: return await asyncio.to_thread(insert_user, name, display, password) diff --git a/compose.yaml b/compose.yaml index 261dc824..092837a2 100644 --- a/compose.yaml +++ b/compose.yaml @@ -47,6 +47,11 @@ services: postgres: condition: service_healthy restart: "no" + deploy: + resources: + limits: + cpus: "0.5" + memory: 256M api: build: . @@ -77,9 +82,9 @@ services: memory: 256M lb: - image: nginx:1.27.5-alpine + image: haproxy:3.2.6-alpine volumes: - - ./infra/nginx.conf:/etc/nginx/nginx.conf:ro + - ./infra/haproxy-compose.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro networks: [front] ports: - "127.0.0.1:${APP_PORT:-8080}:8080" diff --git a/evidence/README.md b/evidence/README.md index 8df70015..1c59b5dc 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -1,5 +1,10 @@ # Доказательства -Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. +- `node_failover.json` — остановка Docker daemon worker1, перенос API на worker2, конкурентный Idempotency-Key, чтение и запись. +- `swarm_rolling_load.json` — 30 секунд записи во время `scripts/swarm-lab.sh rolling-update`. +- `swarm_rolling_update.txt` — завершение поочерёдного обновления сервиса. +- `swarm_load.json` и `swarm_stats.txt` — отдельная 15-секундная нагрузка и срез CPU/RAM узлов. +- `readiness_failover.json` — исключение живой, но неготовой API-реплики активной проверкой HAProxy. +- `history_explain.txt` — план индексного чтения истории на 10 000 синтетических сообщениях. -Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. +Это агрегированные результаты синтетического локального эксперимента. Токены и пароль БД здесь не сохраняются. Команды, ограничения и выводы приведены в [REPORT.md](../REPORT.md). diff --git a/evidence/history_explain.txt b/evidence/history_explain.txt new file mode 100644 index 00000000..7ff36679 --- /dev/null +++ b/evidence/history_explain.txt @@ -0,0 +1,11 @@ +synthetic_chat_id=493ca34c-b101-414a-a747-56017577daf0 +message_count=10000 +Limit (cost=0.29..10.73 rows=101 width=69) (actual time=0.015..0.042 rows=101 loops=1) + Buffers: shared hit=11 + -> Index Scan using messages_history_idx on messages (cost=0.29..1034.81 rows=10000 width=69) (actual time=0.014..0.034 rows=101 loops=1) + Index Cond: (chat_id = '493ca34c-b101-414a-a747-56017577daf0'::uuid) + Buffers: shared hit=11 +Planning: + Buffers: shared hit=109 +Planning Time: 0.406 ms +Execution Time: 0.074 ms diff --git a/evidence/node_failover.json b/evidence/node_failover.json index ff60926b..e64e9bef 100644 --- a/evidence/node_failover.json +++ b/evidence/node_failover.json @@ -1,20 +1,46 @@ { - "before_nodes": [ - "lab3-worker1", - "lab3-worker2" + "before_tasks": [ + { + "task_id": "5qmzptzqohbf", + "node": "lab3-worker2" + }, + { + "task_id": "iypq8msbdy1k", + "node": "lab3-worker1" + } ], - "after_nodes": [ - "lab3-worker2", - "lab3-worker2" + "after_tasks": [ + { + "task_id": "5qmzptzqohbf", + "node": "lab3-worker2" + }, + { + "task_id": "w19aa9l23olu", + "node": "lab3-worker2" + } + ], + "before_instance_ids": [ + "63f148667462", + "8b2a7bca0580" + ], + "after_instance_ids": [ + "63f148667462", + "eb4b7f490edb" ], - "before_instance_count": 2, "concurrent_replays": 16, "concurrent_message_count": 1, - "successful_writes": 96, - "failed_attempts": 0, - "first_success_seconds": 0.02, - "replacement_running_seconds": 20.054, + "concurrent_instance_ids": [ + "63f148667462", + "8b2a7bca0580" + ], + "successful_writes": 92, + "successful_reads": 92, + "failed_post_attempts": 0, + "failed_read_attempts": 0, + "docker_stop_seconds": 1.199, + "first_success_seconds": 1.216, + "replacement_running_seconds": 20.311, "confirmed_messages_preserved": true, - "latency_p50_ms": 14.586, - "latency_p95_ms": 22.945 + "latency_p50_ms": 13.096, + "latency_p95_ms": 16.899 } diff --git a/evidence/readiness_failover.json b/evidence/readiness_failover.json new file mode 100644 index 00000000..1f89378e --- /dev/null +++ b/evidence/readiness_failover.json @@ -0,0 +1,10 @@ +{ + "target_instance_id": "d5c6218cf96c", + "observed_before": [ + "d5c6218cf96c", + "d6788e0998bf" + ], + "excluded_within_seconds": 5.435, + "transient_errors": 2, + "successful_writes_after_exclusion": 10 +} diff --git a/evidence/swarm_load.json b/evidence/swarm_load.json index d01b6311..c1b4eb1f 100644 --- a/evidence/swarm_load.json +++ b/evidence/swarm_load.json @@ -2,16 +2,16 @@ "lab": 3, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 15.0, - "elapsed_seconds": 15.025, + "elapsed_seconds": 15.037, "concurrency": 4, - "successful_requests": 4513, + "successful_requests": 3864, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 300.358, + "successful_rps": 256.971, "successful_latency_ms": { - "p50": 9.415, - "p95": 35.526, - "p99": 77.236 + "p50": 13.08, + "p95": 31.988, + "p99": 60.431 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/swarm_rolling_load.json b/evidence/swarm_rolling_load.json index 1f40fc10..7b5727c1 100644 --- a/evidence/swarm_rolling_load.json +++ b/evidence/swarm_rolling_load.json @@ -2,16 +2,16 @@ "lab": 3, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.041, + "elapsed_seconds": 30.035, "concurrency": 4, - "successful_requests": 10791, + "successful_requests": 7449, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 359.214, + "successful_rps": 248.009, "successful_latency_ms": { - "p50": 8.83, - "p95": 22.727, - "p99": 64.266 + "p50": 12.897, + "p95": 37.412, + "p99": 73.878 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/swarm_rolling_stdout.txt b/evidence/swarm_rolling_stdout.txt deleted file mode 100644 index 1f40fc10..00000000 --- a/evidence/swarm_rolling_stdout.txt +++ /dev/null @@ -1,17 +0,0 @@ -{ - "lab": 3, - "workload": "closed-loop POST messages; no automatic retries", - "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.041, - "concurrency": 4, - "successful_requests": 10791, - "failed_requests": 0, - "error_ratio": 0.0, - "successful_rps": 359.214, - "successful_latency_ms": { - "p50": 8.83, - "p95": 22.727, - "p99": 64.266 - }, - "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." -} diff --git a/evidence/swarm_rolling_update.txt b/evidence/swarm_rolling_update.txt index 76beb7e2..6b371856 100644 --- a/evidence/swarm_rolling_update.txt +++ b/evidence/swarm_rolling_update.txt @@ -22,10 +22,6 @@ overall progress: 0 out of 2 tasks overall progress: 0 out of 2 tasks overall progress: 0 out of 2 tasks overall progress: 0 out of 2 tasks -overall progress: 0 out of 2 tasks -overall progress: 1 out of 2 tasks -overall progress: 1 out of 2 tasks -overall progress: 1 out of 2 tasks overall progress: 1 out of 2 tasks overall progress: 1 out of 2 tasks overall progress: 1 out of 2 tasks diff --git a/evidence/swarm_stats.txt b/evidence/swarm_stats.txt index a603b211..8fe9d558 100644 --- a/evidence/swarm_stats.txt +++ b/evidence/swarm_stats.txt @@ -1,3 +1,3 @@ -lab3-manager 61.49% 272.4MiB / 7.653GiB -lab3-worker1 70.05% 132.1MiB / 7.653GiB -lab3-worker2 85.95% 166.9MiB / 7.653GiB +lab3-manager 68.26% 260.3MiB / 7.653GiB +lab3-worker1 74.43% 150.5MiB / 7.653GiB +lab3-worker2 79.84% 198.8MiB / 7.653GiB diff --git a/infra/README.md b/infra/README.md index 5a39e862..6cdb12d4 100644 --- a/infra/README.md +++ b/infra/README.md @@ -1,7 +1,7 @@ -# Инфраструктура студента +# Инфраструктура -Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли. +`compose.yaml` — основной локальный стенд: HAProxy (`haproxy-compose.cfg`), две API-реплики, отдельный `migrate`, PostgreSQL и Redis. Запуск: `docker compose --env-file .env up -d --build --wait`. `haproxy-swarm.cfg` проверяет адреса задач Swarm через DNS и `/health/ready`. -В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд. +`swarm-data.yaml` и `swarm-app.yaml` используются скриптом `scripts/swarm-lab.sh` для трёх логических узлов. Скрипт сначала поднимает хранилища, затем однократно применяет миграции и запускает API/LB. PostgreSQL закреплён на manager, API — на worker. Остановка одного worker проверяется `tests/node_failover.py`. -Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику. +Версии, лимиты, health/readiness, секреты, доказательства и ограничения описаны в [REPORT.md](../REPORT.md). `compose.example.yaml` остаётся шаблоном задания. diff --git a/infra/haproxy-compose.cfg b/infra/haproxy-compose.cfg new file mode 100644 index 00000000..ecb5abda --- /dev/null +++ b/infra/haproxy-compose.cfg @@ -0,0 +1,27 @@ +global + maxconn 2048 + +defaults + mode http + timeout connect 1s + timeout client 10s + timeout server 10s + timeout check 1s + +resolvers docker + nameserver dns1 127.0.0.11:53 + accepted_payload_size 8192 + hold valid 1s + timeout resolve 1s + timeout retry 1s + +frontend public + bind :8080 + default_backend api + +backend api + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 1s fall 2 rise 2 + server-template replica 2 api:8080 check resolvers docker init-addr none diff --git a/infra/haproxy-swarm.cfg b/infra/haproxy-swarm.cfg new file mode 100644 index 00000000..86059bf8 --- /dev/null +++ b/infra/haproxy-swarm.cfg @@ -0,0 +1,27 @@ +global + maxconn 2048 + +defaults + mode http + timeout connect 1s + timeout client 10s + timeout server 10s + timeout check 1s + +resolvers docker + nameserver dns1 127.0.0.11:53 + accepted_payload_size 8192 + hold valid 1s + timeout resolve 1s + timeout retry 1s + +frontend public + bind :8080 + default_backend api + +backend api + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 1s fall 2 rise 2 + server-template replica 2 tasks.lab3app_api:8080 check resolvers docker init-addr none diff --git a/infra/nginx.conf b/infra/nginx.conf deleted file mode 100644 index 9aa22f18..00000000 --- a/infra/nginx.conf +++ /dev/null @@ -1,21 +0,0 @@ -events { worker_connections 1024; } -http { - access_log off; - resolver 127.0.0.11 valid=1s ipv6=off; - server { - listen 8080; - client_max_body_size 16k; - proxy_connect_timeout 1s; - proxy_read_timeout 5s; - proxy_send_timeout 5s; - proxy_next_upstream error timeout http_502 http_503; - proxy_next_upstream_tries 2; - location / { - set $api http://api:8080; - proxy_pass $api; - proxy_http_version 1.1; - proxy_set_header Host $host; - proxy_set_header X-Request-Id $request_id; - } - } -} diff --git a/infra/swarm-app.yaml b/infra/swarm-app.yaml index 62d54d88..eec2da86 100644 --- a/infra/swarm-app.yaml +++ b/infra/swarm-app.yaml @@ -38,10 +38,10 @@ services: cpus: "0.75" memory: 256M lb: - image: nginx:1.27.5-alpine + image: haproxy:3.2.6-alpine configs: - - source: lab3_nginx_conf - target: /etc/nginx/nginx.conf + - source: lab3_haproxy_conf + target: /usr/local/etc/haproxy/haproxy.cfg networks: [data] ports: - target: 8080 @@ -64,5 +64,5 @@ secrets: lab3_db_password: external: true configs: - lab3_nginx_conf: + lab3_haproxy_conf: external: true diff --git a/scripts/history_explain.py b/scripts/history_explain.py new file mode 100644 index 00000000..23088bb0 --- /dev/null +++ b/scripts/history_explain.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +"""Seed 10k synthetic messages and save the indexed history query plan.""" + +from pathlib import Path +import subprocess +import uuid + + +ROOT = Path(__file__).resolve().parents[1] + + +def psql(sql): + command = ["docker", "compose", "--env-file", ".env", "exec", "-T", "postgres", + "psql", "-U", "messenger", "-d", "messenger", "-X", "-q", "-t", "-A", + "-v", "ON_ERROR_STOP=1", "-c", sql] + return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout.strip() + + +def main(): + owner = psql("SELECT id FROM users ORDER BY created_at LIMIT 1") + if not owner: + raise SystemExit("Run make test first to create a synthetic user") + owner = str(uuid.UUID(owner)) + chat = str(uuid.uuid4()) + psql(f""" + BEGIN; + INSERT INTO chats(id,title) VALUES ('{chat}', 'History index probe'); + INSERT INTO chat_members(chat_id,user_id) VALUES ('{chat}', '{owner}'); + INSERT INTO chat_versions(chat_id) VALUES ('{chat}'); + INSERT INTO messages(id,chat_id,sender_id,text,created_at) + SELECT gen_random_uuid(), '{chat}', '{owner}', 'probe-' || g, + clock_timestamp() + g * interval '1 microsecond' + FROM generate_series(1,10000) AS g; + COMMIT; + ANALYZE messages; + """) + count = psql(f"SELECT count(*) FROM messages WHERE chat_id='{chat}'") + assert count == "10000", count + plan = psql(f""" + EXPLAIN (ANALYZE, BUFFERS) + SELECT id,chat_id,sender_id,text,created_at FROM messages + WHERE chat_id='{chat}' ORDER BY created_at,id LIMIT 101; + """) + result = f"synthetic_chat_id={chat}\nmessage_count={count}\n{plan}\n" + (ROOT / "evidence/history_explain.txt").write_text(result) + print(result) + + +if __name__ == "__main__": + main() diff --git a/scripts/lint.py b/scripts/lint.py index 42c7f894..92848526 100644 --- a/scripts/lint.py +++ b/scripts/lint.py @@ -7,7 +7,7 @@ import sys ROOT = Path(__file__).resolve().parents[1] -FILES = [ROOT / "app/main.py", ROOT / "scripts/migrate.py", ROOT / "scripts/lint.py", ROOT / "tests/node_failover.py"] +FILES = [ROOT / "app/main.py", ROOT / "scripts/migrate.py", ROOT / "scripts/history_explain.py", ROOT / "scripts/lint.py", ROOT / "tests/node_failover.py", ROOT / "tests/level4.py", ROOT / "tests/lb_readiness.py"] def check(path): diff --git a/scripts/swarm-lab.sh b/scripts/swarm-lab.sh index f814b2e0..77ae863f 100755 --- a/scripts/swarm-lab.sh +++ b/scripts/swarm-lab.sh @@ -34,7 +34,7 @@ case "${1:-}" in docker save lab3-api:local | docker exec -i "$node" docker load >/dev/null done python3 -c 'from pathlib import Path; import sys; lines=Path(".env").read_text().splitlines(); values=[line.split("=",1)[1] for line in lines if line.startswith("POSTGRES_PASSWORD=")]; sys.stdout.write(values[-1])' | docker exec -i lab3-manager docker secret create lab3_db_password - >/dev/null - docker exec -i lab3-manager docker config create lab3_nginx_conf - < infra/nginx.conf >/dev/null + docker exec -i lab3-manager docker config create lab3_haproxy_conf - < infra/haproxy-swarm.cfg >/dev/null docker exec -i lab3-manager docker stack deploy --resolve-image never -c - lab3data < infra/swarm-data.yaml count=0 until manager service ls --format '{{.Name}} {{.Replicas}}' | grep -q '^lab3data_postgres 1/1$'; do @@ -42,7 +42,7 @@ case "${1:-}" in test "$count" -lt 120 || { manager service ps lab3data_postgres; exit 1; } sleep 1 done - manager service create --detach=true --name lab3-migrate --network lab3data_data --secret lab3_db_password --env DATABASE_HOST=lab3data_postgres --env DATABASE_NAME=messenger --env DATABASE_USER=messenger --env DATABASE_PASSWORD_FILE=/run/secrets/lab3_db_password --restart-condition on-failure --restart-max-attempts 10 lab3-api:local python -m scripts.migrate >/dev/null + manager service create --detach=true --name lab3-migrate --network lab3data_data --secret lab3_db_password --env DATABASE_HOST=lab3data_postgres --env DATABASE_NAME=messenger --env DATABASE_USER=messenger --env DATABASE_PASSWORD_FILE=/run/secrets/lab3_db_password --restart-condition on-failure --restart-max-attempts 10 --limit-cpu 0.5 --limit-memory 256M lab3-api:local python -m scripts.migrate >/dev/null count=0 until manager service ps --format '{{.CurrentState}}' lab3-migrate | head -1 | grep -q '^Complete'; do count=$((count + 1)) @@ -68,7 +68,7 @@ case "${1:-}" in ;; down) echo "Removing the ephemeral synthetic Swarm cluster and its data." - docker rm -f lab3-manager lab3-worker1 lab3-worker2 >/dev/null + docker rm -fv lab3-manager lab3-worker1 lab3-worker2 >/dev/null docker network rm lab3-nodes >/dev/null ;; *) diff --git a/tests/lb_readiness.py b/tests/lb_readiness.py new file mode 100644 index 00000000..289548cb --- /dev/null +++ b/tests/lb_readiness.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +"""Check that HAProxy removes a live API with failed database readiness.""" + +import json +from pathlib import Path +import subprocess +import time + +from client import Client, Failure + + +PROJECT = "mtusi2026lab3-yurtaev" +TARGET = PROJECT + "-api-1" +NETWORK = PROJECT + "_data" + + +def docker(*args): + return subprocess.check_output(["docker", *args], text=True).strip() + + +def main(): + client = Client("http://127.0.0.1:8080", timeout=2) + alice, _, _, chat = client.bootstrap() + target_id = docker("exec", TARGET, "python", "-c", + "import urllib.request; print(urllib.request.urlopen('http://127.0.0.1:8080/health/live').headers['X-Instance-Id'])") + before = {client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"] + for _ in range(40)} + assert len(before) == 2 and target_id in before, (before, target_id) + start = time.monotonic() + docker("network", "disconnect", NETWORK, TARGET) + try: + consecutive = 0 + errors = 0 + detected_at = None + while time.monotonic() - start < 10: + try: + response = client.call("GET", "/api/v1/users/me", actor=alice, schema="User") + assert response["headers"]["X-Instance-Id"] != target_id + consecutive += 1 + except Failure: + errors += 1 + consecutive = 0 + if consecutive >= 20: + detected_at = time.monotonic() - start + break + time.sleep(0.05) + assert detected_at is not None, "HAProxy did not exclude unready replica" + messages = [client.message(alice, chat, "readiness probe " + str(n))["json"] for n in range(10)] + assert len({message["id"] for message in messages}) == 10 + report = {"target_instance_id": target_id, "observed_before": sorted(before), + "excluded_within_seconds": round(detected_at, 3), "transient_errors": errors, + "successful_writes_after_exclusion": len(messages)} + Path("evidence/readiness_failover.json").write_text(json.dumps(report, indent=2) + "\n") + print(json.dumps(report, indent=2)) + finally: + docker("network", "connect", NETWORK, TARGET) + + +if __name__ == "__main__": + main() diff --git a/tests/level4.py b/tests/level4.py new file mode 100644 index 00000000..5d6d9622 --- /dev/null +++ b/tests/level4.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 +"""Inherited lab 2 level 4 checks through the lab 3 load balancer.""" + +import base64 +import concurrent.futures +import json +import os +from pathlib import Path +import subprocess +import threading +import time +import urllib.error +import urllib.request +import uuid + + +ROOT = Path(__file__).resolve().parents[1] +BASE = os.environ.get("BASE_URL", "http://localhost:8080") + + +def compose(*args, env=None): + return subprocess.run(["docker", "compose", "--env-file", ".env", *args], cwd=ROOT, env=env, check=True, capture_output=True, text=True).stdout + + +def psql(sql): + return compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-t", "-A", "-c", sql) + + +def call(method, path, data=None, auth=None): + headers = {"Accept": "application/json"} + if method == "POST" and path.endswith("/messages"): + headers["Idempotency-Key"] = uuid.uuid4().hex + if data is not None: + headers["Content-Type"] = "application/json" + if auth: + headers["Authorization"] = auth + request = urllib.request.Request(BASE + path, method=method, headers=headers, data=json.dumps(data).encode() if data is not None else None) + try: + with urllib.request.urlopen(request, timeout=10) as response: + return response.status, json.loads(response.read() or b"null") + except urllib.error.HTTPError as error: + return error.code, json.loads(error.read()) + + +def register(name, password): + return call("POST", "/api/v1/users", {"username": name, "display_name": "Synthetic", "password": password}) + + +def login(name, password): + basic = base64.b64encode((name + ":" + password).encode()).decode() + return call("POST", "/api/v1/auth/sessions", auth="Basic " + basic) + + +def main(): + assert register("spaces_" + uuid.uuid4().hex[:12], " " * 12)[0] == 400 + name = "race_" + uuid.uuid4().hex[:12] + password = "synthetic-" + uuid.uuid4().hex + gate = threading.Barrier(16) + def competing_register(_): + gate.wait() + return register(name, password)[0] + with concurrent.futures.ThreadPoolExecutor(max_workers=16) as workers: + statuses = list(workers.map(competing_register, range(16))) + assert statuses.count(201) == 1 and statuses.count(409) == 15, statuses + status, session = login(name, password) + assert status == 201 + basic = base64.b64encode((name + ":" + password).encode()).decode() + assert call("POST", "/api/v1/auth/sessions", {"unexpected": "body"}, "Basic " + basic)[0] == 400 + token = "Bearer " + session["token"] + user_id = session["user"]["id"] + status, chat = call("POST", "/api/v1/chats", {"title": "Failure test", "member_ids": [user_id]}, token) + assert status == 201 + probe = "rollback_" + uuid.uuid4().hex + psql("CREATE FUNCTION lab2_rollback_guard() RETURNS trigger LANGUAGE plpgsql AS $$ " + f"BEGIN IF EXISTS (SELECT 1 FROM chats WHERE id=NEW.chat_id AND title='{probe}') " + "THEN RAISE EXCEPTION 'rollback probe'; END IF; RETURN NEW; END $$;") + psql("CREATE TRIGGER lab2_rollback_guard BEFORE INSERT ON chat_members " + "FOR EACH ROW EXECUTE FUNCTION lab2_rollback_guard();") + try: + assert call("POST", "/api/v1/chats", {"title": probe, "member_ids": [user_id]}, token)[0] == 500 + assert psql(f"SELECT count(*) FROM chats WHERE title='{probe}'").strip() == "0" + finally: + psql("DROP TRIGGER lab2_rollback_guard ON chat_members; DROP FUNCTION lab2_rollback_guard();") + path = "/api/v1/chats/" + chat["id"] + "/messages" + assert call("POST", path, {"text": "before outage"}, token)[0] == 201 + malformed = base64.urlsafe_b64encode(json.dumps([chat["id"], 17, user_id]).encode()).decode().rstrip("=") + assert call("GET", path + "?cursor=" + malformed, auth=token)[0] == 400 + assert call("GET", path + "?limit=" + "9" * 100, auth=token)[0] == 400 + missing_status, missing_body = call("GET", "/api/v1/missing", auth=token) + assert missing_status == 404 and missing_body["error"]["code"] == "not_found" + compose("stop", "redis") + try: + assert call("GET", path, auth=token)[0] == 200 + assert call("POST", path, {"text": "during cache outage"}, token)[0] == 201 + assert call("GET", path, auth=token)[1]["items"][-1]["text"] == "during cache outage" + assert call("GET", "/api/v1/users/me", auth="Bearer invalid")[0] == 401 + finally: + compose("start", "redis") + compose("stop", "postgres") + try: + assert call("GET", "/health/ready")[0] == 503 + assert call("GET", "/api/v1/users/me", auth=token)[0] == 503 + finally: + compose("start", "postgres") + for _ in range(40): + if call("GET", "/health/ready")[0] == 200: + break + time.sleep(0.5) + else: + raise AssertionError("PostgreSQL did not recover") + # Expiry is checked against PostgreSQL time, without a Redis dependency. + env = dict(os.environ, SESSION_TTL_SECONDS="2") + compose("up", "-d", "--force-recreate", "--wait", "api", env=env) + try: + short = login(name, password)[1]["token"] + time.sleep(3) + assert call("GET", "/api/v1/users/me", auth="Bearer " + short)[0] == 401 + finally: + compose("up", "-d", "--force-recreate", "--wait", "api") + print("PASS: username race, chat rollback, Redis fallback, PostgreSQL failure, session expiry") + + +if __name__ == "__main__": + main() diff --git a/tests/node_failover.py b/tests/node_failover.py index 8bb50657..9eb4c01f 100644 --- a/tests/node_failover.py +++ b/tests/node_failover.py @@ -2,6 +2,7 @@ """Exercise a real Swarm worker loss while reading and writing through the LB.""" import argparse +from collections import Counter from concurrent.futures import ThreadPoolExecutor import json from pathlib import Path @@ -9,6 +10,7 @@ import statistics import subprocess import time import uuid +from urllib.parse import quote from client import Client, Failure @@ -16,10 +18,23 @@ from client import Client, Failure def tasks(): result = subprocess.check_output([ "docker", "exec", "lab3-manager", "docker", "service", "ps", - "--filter", "desired-state=running", "--format", "{{.Node}} {{.CurrentState}}", + "--filter", "desired-state=running", "--format", "{{.ID}} {{.Node}} {{.CurrentState}}", "lab3app_api", ], text=True) - return [line.split()[0] for line in result.splitlines() if "Running" in line] + return [{"task_id": parts[0], "node": parts[1]} for line in result.splitlines() + if len(parts := line.split()) >= 3 and parts[2] == "Running"] + + +def history(client, actor, chat): + path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100" + items = [] + for _ in range(100): + page = client.call("GET", path, actor=actor, schema="MessagePage")["json"] + items.extend(page["items"]) + if page["next_cursor"] is None: + return items + path = "/api/v1/chats/" + chat["id"] + "/messages?limit=100&cursor=" + quote(page["next_cursor"], safe="") + raise AssertionError("history pagination did not terminate") def main(): @@ -31,7 +46,7 @@ def main(): client = Client(args.base_url, timeout=2) alice, bob, _, chat = client.bootstrap() before = tasks() - assert len(before) == 2 and args.worker in before, before + assert len(before) == 2 and args.worker in {task["node"] for task in before}, before instances = { client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"] for _ in range(40) @@ -41,13 +56,19 @@ def main(): key = uuid.uuid4().hex body = "concurrent " + key with ThreadPoolExecutor(max_workers=16) as executor: - results = list(executor.map(lambda _: client.message(alice, chat, body, key=key)["json"], range(16))) + responses = list(executor.map(lambda _: client.message(alice, chat, body, key=key), range(16))) + results = [response["json"] for response in responses] + concurrent_instances = {response["headers"]["X-Instance-Id"] for response in responses} assert all(item == results[0] for item in results) + assert len(concurrent_instances) >= 2, concurrent_instances - subprocess.run(["docker", "stop", "-t", "1", args.worker], check=True, stdout=subprocess.DEVNULL) start = time.monotonic() - successes = [] - errors = 0 + subprocess.run(["docker", "stop", "-t", "1", args.worker], check=True, stdout=subprocess.DEVNULL) + stop_return_seconds = time.monotonic() - start + successes = {} + post_errors = 0 + read_errors = 0 + successful_reads = 0 latencies = [] moved_at = None first_success = None @@ -56,35 +77,53 @@ def main(): while time.monotonic() - start < 75: try: response = client.message(alice, chat, pending_text, key=pending_key) - successes.append(response["json"]) + assert pending_key not in successes + successes[pending_key] = response["json"] + latest_id = response["json"]["id"] latencies.append(response["elapsed"] * 1000) if first_success is None: first_success = time.monotonic() - start - client.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=1", actor=bob, schema="MessagePage") pending_key = uuid.uuid4().hex pending_text = "node-fail " + pending_key except Failure: - errors += 1 + post_errors += 1 + else: + try: + assert latest_id in {item["id"] for item in history(client, bob, chat)} + successful_reads += 1 + except Failure: + read_errors += 1 current = tasks() - if len(current) == 2 and args.worker not in current and moved_at is None: + if len(current) == 2 and args.worker not in {task["node"] for task in current} and moved_at is None: moved_at = time.monotonic() - start if moved_at is not None and time.monotonic() - start > moved_at + 5: break time.sleep(0.15) assert moved_at is not None, tasks() assert successes, "no writes during node failure" - page = client.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", actor=bob, schema="MessagePage")["json"] - seen = {item["id"] for item in page["items"]} - assert results[0]["id"] in seen and all(item["id"] in seen for item in successes) - assert sum(item["text"] == body for item in page["items"]) == 1 + items = history(client, bob, chat) + ids = Counter(item["id"] for item in items) + texts = Counter(item["text"] for item in items) + assert ids[results[0]["id"]] == 1 and texts[body] == 1 + assert all(ids[item["id"]] == 1 and texts[item["text"]] == 1 for item in successes.values()) + after_instances = { + client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"] + for _ in range(40) + } + assert after_instances - instances, (instances, after_instances) report = { - "before_nodes": before, - "after_nodes": tasks(), - "before_instance_count": len(instances), + "before_tasks": before, + "after_tasks": tasks(), + "before_instance_ids": sorted(instances), + "after_instance_ids": sorted(after_instances), "concurrent_replays": len(results), "concurrent_message_count": 1, + "concurrent_instance_ids": sorted(concurrent_instances), "successful_writes": len(successes), - "failed_attempts": errors, + "successful_reads": successful_reads, + "failed_post_attempts": post_errors, + "failed_read_attempts": read_errors, + "docker_stop_seconds": round(stop_return_seconds, 3), "first_success_seconds": round(first_success, 3), "replacement_running_seconds": round(moved_at, 3), "confirmed_messages_preserved": True, -- 2.54.0