diff --git a/.dockerignore b/.dockerignore index bc16e556..ab67a3ad 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,20 +1,6 @@ .git -.github -.env -.env.* -!.env.example -secrets -certs -volumes -data -backups -*.key -*.pem -*.p12 -*.pfx -*.jks .venv __pycache__ -node_modules -evidence -.DS_Store +secrets +.env +*.pyc diff --git a/.env.example b/.env.example index d99d26a2..5cd5f81e 100644 --- a/.env.example +++ b/.env.example @@ -11,7 +11,7 @@ SESSION_STORE=postgres CACHE_URL_FILE=/run/secrets/cache_url API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 -S3_ENDPOINT=http://s3:9000 +S3_ENDPOINT=http://rustfs:9000 S3_REGION=us-east-1 S3_BUCKET=messenger-attachments S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..25fd1868 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,11 @@ +FROM python:3.12.12-slim +WORKDIR /srv +COPY requirements.lock . +RUN pip install --no-cache-dir --timeout 120 --retries 5 -r requirements.lock +COPY app app +COPY migrations migrations +COPY scripts scripts +RUN useradd --uid 10001 --create-home api +USER api +EXPOSE 8080 +CMD ["gunicorn", "--bind", "0.0.0.0:8080", "--workers", "1", "--threads", "2", "--timeout", "35", "--graceful-timeout", "5", "--keep-alive", "1", "app.main:app"] diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..24d3db42 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,90 @@ # Отчёт — лабораторная 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Дыханова Алина БВТ2301 +- Целевая оценка: 5; выбранный трек 2 - согласованность PostgreSQL/S3 +- Источники, библиотеки и помощь ИИ: контракт и материалы репозитория; Flask, psycopg, Argon2, boto3, Pillow, RustFS, PostgreSQL, HAProxy, Redis. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Desktop/Engine и Compose v2; первый запуск скачивает образы и Python-зависимости. Секреты создаются локально, не коммитятся и не печатаются: + +```sh +python3 scripts/bootstrap.py +docker compose config --quiet +docker compose up -d --build --scale api=2 --wait --wait-timeout 180 +make check +make test +python3 tests/attachments_negative.py +``` + +`bootstrap.py` создаёт `secrets/` с правами 0700, файлы секретов — 0600, сохраняет уже существующие значения и создаёт `.env`. Bucket `messenger-attachments` идемпотентно создаётся `bucket-bootstrap`. Root RustFS credentials используются только для bootstrap; API получает отдельного IAM пользователя и policy с ограниченными правами к bucket. RustFS console выключена, портов object storage на host нет. + +Безопасно остановить стенд с сохранением данных: `docker compose down`. Намеренно удалить учебные данные вместе с volumes: `docker compose down -v` (необратимо). Проверки сохранности/failover: `make test-persistence ACTION_SCRIPT=scripts/restart.sh` и `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`. Запуск исследования трека 2: `docker compose exec -T api python scripts/reconcile_experiment.py`. Dry-run полного inventory: `docker compose exec -T api python scripts/reconcile.py`. После лабораторной остановить стенд без удаления данных: `docker compose down`. + +Проверено 2026-11-06 на Docker Engine 29.8.0, Docker Desktop; в Compose закреплены `rustfs/rustfs:1.0.3-glibc`, `rustfs/rc:v0.1.37`, `postgres:16.10-alpine`, `redis:7.4.6-alpine`, `haproxy:3.0.11-alpine`; приложение — `python:3.12.12-slim`. Docker Compose `config --quiet`, сборка, запуск с двумя API replica и все указанные ниже сквозные проверки завершились успешно. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +клиент → HAProxy → API × 2 + ├── PostgreSQL: users, sessions, chats, messages, attachment metadata + ├── Redis: необязательный кэш профиля + └── приватный RustFS (S3): оригиналы изображений +``` + +Перенесены регистрация и Argon2id-аутентификация, сессии, чаты, keyset-пагинация и транзакционная идемпотентность сообщений из предыдущих лабораторных. Вложение получает UUID и серверный object key `{chat_id}/{attachment_id}`; исходное имя используется только для отображения. Upload ограничен 10 MiB до чтения тела, проверяется сигнатура/формат PNG/JPEG через Pillow и ограничение 40 млн пикселей. Bytes синхронно сохраняются в S3, metadata — в PostgreSQL; `201 ready` возвращается после сохранения обоих. Download проверяет членство в чате и возвращает исходные bytes через API без redirect. + +S3 и PostgreSQL не образуют общую транзакцию. При обычной ошибке записи metadata код пытается удалить загруженный объект. При аварийном завершении или сбое компенсации reconciler обнаруживает orphan. В обычном режиме удаляются только объекты старше 24 часов, отсутствующие в БД; каждый ключ проверяется на ссылку ещё раз перед удалением. Missing-объекты только сообщаются, metadata не удаляется. Параметр `--allow-short-grace` разрешён только вместе с изолированным `--prefix` для теста; его нельзя применять к полному bucket. + +Переменные `.env.example` сопоставлены реальному Compose: `DATABASE_URL_FILE`, `CACHE_URL_FILE`, `S3_ACCESS_KEY_ID_FILE`, `S3_SECRET_ACCESS_KEY_FILE`, `S3_ENDPOINT=http://rustfs:9000`, `S3_REGION`, `S3_BUCKET`, `SESSION_TTL_SECONDS`, `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS`. Root и API credentials передаются через Docker secrets. Сервис RustFS слушает только внутреннюю сеть Compose. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Офлайн-контракт | `make check` | PASS: проверены skeleton refs и синтаксис; приложение отдельно проверено ниже | stdout проверки; `scripts/check_contract.py` | +| Compose/сборка/готовность | `docker compose config --quiet`; `docker compose up -d --build --scale api=2 --wait` | PASS: RustFS, PostgreSQL, Redis, API×2 и HAProxy healthy; bucket bootstrap и migration завершились с кодом 0 | `compose.yaml`, `evidence/runtime-checks.json` | +| Публичный smoke lab4 | `make test` | PASS: сквозной API, checksum/байты оригинала, чтение участником, отказ постороннему | `tests/smoke.py`, `evidence/runtime-checks.json` | +| PNG/JPEG и ошибки загрузки/доступа | `python3 tests/attachments_negative.py` | PASS: реальные PNG/JPEG загружаются; JPEG скачан участником побайтно; corrupt image=415, MIME spoof=415, 10 MiB+1=413, 40 972 801 пиксель=413, опасное имя=400, чужой attachment metadata/content=404, привязка к другому чату=404 | `tests/attachments_negative.py`, `tests/fixtures/sample.jpg`, `evidence/runtime-checks.json` | +| Недоступный напрямую приватный bucket | Unsigned S3 GET существующего object key из API network namespace | PASS: RustFS вернул `AccessDenied`; порт S3 не опубликован на host | `infra/rustfs-policy.json`, `evidence/runtime-checks.json` | +| Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS: hook сделал `docker compose down` и `up` без удаления volumes; старый bearer token, данные чата, сообщения и оригинал сохранились | `scripts/restart.sh`, `evidence/runtime-checks.json` | +| API failover | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | PASS: до отказа наблюдались 2 реплики; 127 успешных подтверждений, 2 переходных ошибки; первое восстановление записи через 1,273 с; остановленная реплика не обслуживала последние запросы; история и вложение проверены второй стороной | `scripts/stop-one.sh`, `evidence/runtime-checks.json` | +| Недоступность S3 | `python3 tests/s3_unavailable.py` | PASS: upload получил 503, число metadata rows не выросло, RustFS был запущен обратно и стал healthy | `tests/s3_unavailable.py`, `evidence/runtime-checks.json` | +| ≥10 параллельных upload и память | `python3 tests/upload_load.py --base-url http://localhost:8080` | PASS: 10 клиентов; 100 small и 30 large uploads, ошибок 0. На большом профиле Docker stats зафиксировал 135,9 MiB и 133,5 MiB для двух API при лимите 512 MiB на реплику | `tests/upload_load.py`, `evidence/upload-load.json` | +| Трек 2: две стороны состояния, dry-run/apply/повтор | `docker compose exec -T api python scripts/reconcile_experiment.py` | PASS: свежий orphan пережил apply до grace; после aging был удалён только он; missing остался для диагностики, повторный dry-run стабилен; контрольное ready-вложение побайтно сохранилось | `scripts/reconcile_experiment.py`, `scripts/reconcile.py`, `evidence/reconcile-experiment.json` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Сохранность проверялась реальным Compose hook: он остановил и удалил контейнеры всех сервисов, но оставил named volumes; затем заново создал PostgreSQL, RustFS, Redis, миграцию, API и LB. Failover hook остановил только ту API replica, чей alias вернул запрос; другая продолжила обслуживать запросы. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### Трек 2: гипотеза и результаты -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +**Гипотеза.** Reconciler сравнивает ссылки `attachments.object_key` с S3 inventory. Dry-run безопасен и только сообщает missing/orphan. В apply удаляются лишь неиспользуемые orphan старше grace period; missing и свежие/используемые объекты не удаляются. Повторный проход даёт стабильный результат. + +**Повторяемая методика.** Команда `scripts/reconcile_experiment.py` создаёт уникальный S3 prefix, пишет один orphan object и одну metadata row с отсутствующим object key, выбирает существующее вложение как sentinel и сохраняет его SHA-256. Далее она запускает dry-run, сразу применяет с grace 3600 секунд и проверяет, что свежий orphan не удалён; ждёт 2,1 с, применяет `--grace-seconds 1 --allow-short-grace --prefix `, повторяет dry-run, сверяет sentinel и удаляет искусственную missing metadata row. Короткий grace ограничен уникальным prefix, существующие объекты лежат вне него. + +**Результат прогона 2026-11-06.** Dry-run увидел `db_rows=1`, `s3_objects=1`, одну missing ссылку и один orphan, не удалил ничего. Немедленный apply с grace 3600 секунд тоже сохранил свежий orphan (`eligible_orphans=[]`). После ожидания 2,1 с apply с тестовым grace 1 секунда удалил только orphan. Повторный dry-run увидел `s3_objects=0`, orphan отсутствовал, missing запись осталась обнаруженной. Sentinel-вложение осталось ready и его SHA-256 совпал до/после. Время каждого обхода сохранено в JSON. После опыта тестовую missing row удалили; учебные файлы, загруженные smoke/load прогонами, оставлены в стенде. + +### Нагрузка и отказы + +Для upload нагрузки использованы детерминированные PNG с шумом: 512×512 (787 247 байт, 262 144 пикселя) и 2048×1536 (9 441 653 байта, 3 145 728 пикселей). 10 worker начали параллельно; каждый сделал 10 запросов малого профиля и 3 большого. Это closed-loop синтетический опыт на локальном Docker Desktop без TLS. Метрики RPS и percentiles — только успешных запросов; генератор и измерение отражают эту конкретную машину, не production capacity. Docker stats обновляется примерно раз в секунду, поэтому пиковая память является sampled maximum и может не поймать короткий пик. В small-профиле длительность была около 1,3 с, отдельная выборка памяти не успела накопиться; для large доступно два telemetry sample. + +| Профиль | Успешно / ошибки | Время | Успешных RPS | p50 / p95 / p99 | Пик памяти API-1 / API-2 | +| --- | ---: | ---: | ---: | ---: | ---: | +| 512×512, 0,75 MiB, 100 загрузок | 100 / 0 | 1,294 с | 77,277 | 50,69 / 87,39 / 105,97 мс | sampled отдельно не зафиксирован | +| 2048×1536, 9,01 MiB, 30 загрузок | 30 / 0 | 1,933 с | 15,519 | 328,39 / 476,86 / 599,46 мс | 135,9 / 133,5 MiB | + +Контейнеры API ограничены 512 MiB каждый и 0,75 CPU; память измерялась отдельно для двух реплик. Большой профиль держал API ниже 27% лимита по последнему sampled максимуму. Нагрузка закрытого типа и имеет coordinated omission; эти цифры характеризуют только описанный стенд. + +| Воздействие | Что ожидали | Что наблюдали | Восстановление / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Слишком большой upload | 413 до декодирования | Получен 413 на 10 MiB+1 | Мгновенный отказ, записей нет | +| Испорченный файл / подменённый MIME / опасное имя | 415 / 415 / 400 | Коды совпали; API не вернул 500 | Без побочных объектов | +| Посторонний user и вложение из другого чата | 404 без раскрытия metadata/bytes | Получен 404 на metadata, content и cross-chat attachment_ids | Данные не изменились | +| Остановка одной API replica | другая реплика продолжает подтверждать POST | 127 подтверждений, 2 переходных ошибки; восстановление за 1,273 с | Подтверждённые сообщения и оригинал не потеряны, дублей нет | +| Restart всех сервисов с volumes | старые токены, сообщения и bytes доступны | persistence hook завершился PASS | Потери нет; все зависимости реально перезапущены | +| Missing+orphan и повторный reconciler | удалить старый неиспользуемый orphan, сохранить missing и sentinel | Обнаружены обе неисправности, удалён только orphan, повтор стабилен | Sentinel bytes/checksum сохранены | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Работа подтверждена на локальном учебном стенде, но не является production deployment. Reconciler не восстанавливает утраченные bytes; он сохраняет metadata missing объекта для диагностики. Полный обход текущего bucket (424 metadata и 424 objects) занял 0,1364 с; стоимость на больших bucket надо измерять отдельно. Распределённой транзакции между S3 и PostgreSQL нет. Полный пик памяти может быть выше sampled Docker stats. Полную OpenAPI-валидацию (`make validate`) не удалось запустить: `openapi-spec-validator` отсутствовал локально, а установка из package index была недоступна из этой среды; `make check` и все runtime smoke/negative проверки выполнены. Не реализованы UI, thumbnail/background worker и presigned flow: они не входят в обязательный контракт lab4. diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..4d0986b2 --- /dev/null +++ b/app/main.py @@ -0,0 +1,282 @@ +import base64 +import datetime as dt +import hashlib +import json +import os +import re +import secrets +import uuid +from flask import Flask, request, g +from werkzeug.utils import secure_filename +from werkzeug.exceptions import HTTPException +from argon2 import PasswordHasher +from argon2.exceptions import VerificationError +from psycopg.rows import dict_row +from psycopg.errors import UniqueViolation +from psycopg_pool import ConnectionPool +import psycopg +import redis +import boto3 +from botocore.config import Config +from PIL import Image, UnidentifiedImageError +import io +from urllib.parse import quote +from app.migrate import setting + +app = Flask(__name__) +MAX_UPLOAD=int(os.getenv('MAX_UPLOAD_BYTES','10485760')) +MAX_PIXELS=int(os.getenv('MAX_IMAGE_PIXELS','40000000')) +app.config['MAX_CONTENT_LENGTH'] = MAX_UPLOAD +pool = ConnectionPool(setting('DATABASE_URL'), min_size=1, max_size=int(os.getenv('POOL_MAX','8')), timeout=3, + kwargs={'row_factory':dict_row,'connect_timeout':3,'options':'-c statement_timeout=3000 -c lock_timeout=2000'}) +cache = redis.Redis.from_url(setting('CACHE_URL'),socket_connect_timeout=.2,socket_timeout=.2) +kdf = PasswordHasher(time_cost=2,memory_cost=19456,parallelism=1) +dummy = kdf.hash(secrets.token_urlsafe(32)) +ttl = int(os.getenv('SESSION_TTL_SECONDS','3600')) +def envsetting(name): return setting(name) if os.getenv(name+'_FILE') else os.environ[name] +s3=boto3.client('s3',endpoint_url=os.getenv('S3_ENDPOINT','http://rustfs:9000'),region_name=os.getenv('S3_REGION','us-east-1'),aws_access_key_id=envsetting('S3_ACCESS_KEY_ID'),aws_secret_access_key=envsetting('S3_SECRET_ACCESS_KEY'),config=Config(connect_timeout=2,read_timeout=5,retries={'max_attempts':1})) +bucket=os.getenv('S3_BUCKET','messenger-attachments') +instance = os.getenv('HOSTNAME','api') + '-' + secrets.token_hex(4) + +class Problem(Exception): + def __init__(self,status,code): self.status,self.code=status,code + +def fail(status,code): raise Problem(status,code) +def invalid(): fail(400,'invalid_request') +def uid(value): + try: return str(uuid.UUID(value)) + except (ValueError,TypeError,AttributeError): invalid() +def clean(row): + return {k:(v.isoformat().replace('+00:00','Z') if isinstance(v,dt.datetime) else str(v) if isinstance(v,uuid.UUID) else v) for k,v in row.items()} +def user(row): return clean({k:row[k] for k in ('id','username','display_name','created_at')}) +def body(fields): + if request.mimetype != 'application/json': fail(415,'unsupported_media_type') + try: data = request.get_json() + except HTTPException: invalid() + if not isinstance(data,dict) or set(data)!=set(fields): invalid() + return data +def string(s,maximum,minimum=1): + if not isinstance(s,str) or not s.strip() or not minimum<=len(s)<=maximum: invalid() + try: s.encode('utf-8') + except UnicodeError: invalid() + return s + +def actor(c): + auth = request.headers.get('Authorization','') + if not auth.startswith('Bearer ') or not 1<=len(auth[7:])<=256: fail(401,'unauthorized') + digest = hashlib.sha256(auth[7:].encode()).hexdigest() + row=c.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at>clock_timestamp()',(digest,)).fetchone() + if not row: fail(401,'unauthorized') + g.digest=digest + return row['user_id'] + +def public_user(c,ident): + key='user:'+str(ident) + try: + value=cache.get(key) + if value: return json.loads(value) + except (redis.RedisError,ValueError): pass + result=user(c.execute('SELECT * FROM users WHERE id=%s',(ident,)).fetchone()) + try: cache.setex(key,60,json.dumps(result)) + except redis.RedisError: pass + return result + +def chat(c,ident,who): + row=c.execute('SELECT c.* FROM chats c JOIN members m ON c.id=m.chat_id WHERE c.id=%s AND m.user_id=%s',(ident,who)).fetchone() + if not row: fail(404,'not_found') + row=clean(row) + row['member_ids']=[str(x['user_id']) for x in c.execute('SELECT user_id FROM members WHERE chat_id=%s ORDER BY user_id',(ident,))] + return row + +def page_args(resource): + if set(request.args)-{'limit','cursor'} or any(len(request.args.getlist(k))!=1 for k in request.args): invalid() + raw=request.args.get('limit','50') + if len(raw)>3 or not re.fullmatch(r'[0-9]+',raw) or not 1<=int(raw)<=100: invalid() + cursor=request.args.get('cursor') + pair=None + if cursor is not None: + try: + data=json.loads(base64.b64decode(cursor,altchars=b'-_',validate=True)) + if not isinstance(data,list) or len(data)!=3 or data[0]!=resource: invalid() + stamp=dt.datetime.fromisoformat(data[1].replace('Z','+00:00')) + if stamp.tzinfo is None: invalid() + pair=(stamp,uid(data[2])) + except (ValueError,TypeError,KeyError,AttributeError,OverflowError): invalid() + return int(raw),pair + +def page(rows,limit,resource): + more=len(rows)>limit + rows=rows[:limit] + cursor=base64.urlsafe_b64encode(json.dumps([resource,rows[-1]['created_at'],rows[-1]['id']]).encode()).decode() if more else None + return {'items':rows,'next_cursor':cursor} + +@app.before_request +def before(): g.request_id=str(uuid.uuid4()) +@app.after_request +def after(response): + response.headers['X-Request-Id']=g.request_id + response.headers['X-Instance-Id']=instance + return response +@app.errorhandler(Exception) +def error(exc): + if isinstance(exc,Problem): status,code=exc.status,exc.code + elif isinstance(exc,UniqueViolation): status,code=409,'conflict' + elif isinstance(exc,(psycopg.Error, __import__('psycopg_pool').PoolTimeout)): status,code=503,'unavailable' + elif isinstance(exc,HTTPException): + status=exc.code + code={404:'not_found',413:'payload_too_large',415:'unsupported_media_type'}.get(status,'invalid_request') + else: + app.logger.error('Unhandled exception type: %s',type(exc).__name__) + status,code=500,'internal_error' + response=app.json.response({'error':{'code':code,'message':code,'request_id':g.request_id}}) + response.status_code=status + if status==401: + response.headers['WWW-Authenticate']='Basic realm="messenger", charset="UTF-8"' if request.path=='/api/v1/auth/sessions' else 'Bearer realm="messenger"' + return response +@app.get('/health/live') +def live(): return {'status':'ok'} +@app.get('/health/ready') +def ready(): + with pool.connection() as c: c.execute('SELECT 1') + return {'status':'ok'} + +@app.route('/api/v1/',methods=['GET','POST','DELETE']) +def api(path): + public = (path in ('users','auth/sessions') and request.method=='POST') + if not public and not request.headers.get('Authorization','').startswith('Bearer '): fail(401,'unauthorized') + with pool.connection() as c: + if path=='users' and request.method=='POST': + d=body(['username','display_name','password']) + if not isinstance(d['username'],str) or not re.fullmatch('[a-z0-9_]{3,32}',d['username']): invalid() + string(d['display_name'],100); string(d['password'],128,12) + row=c.execute('INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING *',(uuid.uuid4(),d['username'],d['display_name'],kdf.hash(d['password']))).fetchone() + return user(row),201 + if path=='auth/sessions' and request.method=='POST': + a=request.headers.get('Authorization','') + try: + if not a.startswith('Basic ') or request.get_data(): raise ValueError() + name,password=base64.b64decode(a[6:],validate=True).decode('utf-8').split(':',1) + except (ValueError,UnicodeError): fail(401,'unauthorized') + row=c.execute('SELECT * FROM users WHERE username=%s',(name,)).fetchone() + try: valid=kdf.verify(row['password_hash'] if row else dummy,password) + except VerificationError: valid=False + if not valid or not row: fail(401,'unauthorized') + token=secrets.token_urlsafe(32) + expires=c.execute("INSERT INTO sessions VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at",(hashlib.sha256(token.encode()).hexdigest(),row['id'],ttl)).fetchone()['expires_at'] + return {'token':token,'token_type':'Bearer','expires_at':expires.isoformat().replace('+00:00','Z'),'user':user(row)},201 + who=actor(c) + if path=='auth/sessions/current' and request.method=='DELETE': + c.execute('DELETE FROM sessions WHERE token_hash=%s',(g.digest,)) + return '',204 + if path=='users/me' and request.method=='GET': return public_user(c,who) + if path=='chats': + if request.method=='POST': + d=body(['title','member_ids']); string(d['title'],100) + ids=d['member_ids'] + if not isinstance(ids,list) or not 1<=len(ids)<=100: invalid() + ids=[uid(x) for x in ids] + if len(ids)!=len(set(ids)) or str(who) not in ids: invalid() + if c.execute('SELECT count(*) AS n FROM users WHERE id=ANY(%s::uuid[])',(ids,)).fetchone()['n']!=len(ids): invalid() + ident=uuid.uuid4() + c.execute('INSERT INTO chats(id,title) VALUES (%s,%s)',(ident,d['title'])) + for member in ids: c.execute('INSERT INTO members VALUES (%s,%s)',(ident,member)) + return chat(c,ident,who),201 + if request.method=='GET': + resource='chats:'+str(who); limit,pair=page_args(resource) + query='SELECT c.id FROM chats c JOIN members m ON c.id=m.chat_id WHERE m.user_id=%s' + params=[who] + if pair: query+=' AND (c.created_at,c.id)>(%s,%s)'; params+=list(pair) + query+=' ORDER BY c.created_at,c.id LIMIT %s'; params+=[limit+1] + return page([chat(c,x['id'],who) for x in c.execute(query,params).fetchall()],limit,resource) + parts=path.split('/') + if len(parts) in (2,3) and parts[0]=='chats': + ident=uid(parts[1]) + if len(parts)==3 and parts[2]=='messages' and os.getenv('MESSAGE_ACCESS_FAST','1')=='1': + # Message endpoints only need membership, not the entire Chat representation. + if not c.execute('SELECT 1 FROM members WHERE chat_id=%s AND user_id=%s',(ident,who)).fetchone(): fail(404,'not_found') + result=None + else: + result=chat(c,ident,who) + if len(parts)==2 and request.method=='GET': return result + if len(parts)==3 and parts[2]=='messages': + if request.method=='POST': + key=request.headers.get('Idempotency-Key','') + if not re.fullmatch(r'[A-Za-z0-9._:-]{1,128}',key): invalid() + if request.mimetype != 'application/json': fail(415,'unsupported_media_type') + try: d=request.get_json() + except HTTPException: invalid() + if not isinstance(d,dict) or set(d)-{'text','attachment_ids'} or 'text' not in d: invalid() + if not isinstance(d['text'],str) or len(d['text'])>4000: invalid() + aids=d.get('attachment_ids',[]) + if not isinstance(aids,list) or len(aids)>10: invalid() + aids=[uid(x) for x in aids] + if len(set(aids))!=len(aids): invalid() + if not d['text'].strip() and not aids: invalid() + if aids: + found=c.execute('SELECT id,status FROM attachments WHERE chat_id=%s AND id=ANY(%s::uuid[])',(ident,aids)).fetchall() + if len(found)!=len(aids): fail(404,'not_found') + canonical=json.dumps({'text':d['text'],'attachment_ids':aids},sort_keys=True,ensure_ascii=False) + # One transaction: lock scope, inspect replay, insert effect and result, commit before response. + scope=str(who)+':POST:'+ident+':'+key + c.execute('SELECT pg_advisory_xact_lock(hashtextextended(%s,0))',(scope,)) + old=c.execute('SELECT body,response FROM idempotency WHERE user_id=%s AND chat_id=%s AND key=%s AND expires_at>clock_timestamp()',(who,ident,key)).fetchone() + if old: + if old['body']!=canonical: fail(409,'conflict') + return old['response'],201 + mid=uuid.uuid4() + result=clean(c.execute('INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *',(mid,ident,who,d['text'])).fetchone()) + result['attachment_ids']=aids + for pos,aid in enumerate(aids): c.execute('INSERT INTO message_attachments VALUES (%s,%s,%s)',(mid,aid,pos)) + c.execute("INSERT INTO idempotency(user_id,chat_id,key,body,response,expires_at) VALUES (%s,%s,%s,%s,%s,clock_timestamp()+interval '24 hours') ON CONFLICT(user_id,chat_id,key) DO UPDATE SET body=excluded.body,response=excluded.response,expires_at=excluded.expires_at",(who,ident,key,canonical,psycopg.types.json.Jsonb(result))) + return result,201 + if request.method=='GET': + limit,pair=page_args(ident) + query='SELECT * FROM messages WHERE chat_id=%s'; params=[ident] + if pair: query+=' AND (created_at,id)>(%s,%s)'; params+=list(pair) + query+=' ORDER BY created_at,id LIMIT %s'; params+=[limit+1] + items=[clean(x) for x in c.execute(query,params)] + for m in items: m['attachment_ids']=[str(x['attachment_id']) for x in c.execute('SELECT attachment_id FROM message_attachments WHERE message_id=%s ORDER BY position',(m['id'],))] + return page(items,limit,ident) + if len(parts)==3 and parts[2]=='attachments' and request.method=='POST': + filename=request.args.get('filename','') + if len(filename)<1 or len(filename)>255 or any(ord(ch)<32 or ch in '/\\' for ch in filename): invalid() + if request.mimetype not in ('image/png','image/jpeg'): fail(415,'unsupported_media_type') + raw=request.get_data(cache=False) + if not raw: invalid() + try: + im=Image.open(io.BytesIO(raw)); fmt=im.format; w,h=im.size + if w*h>MAX_PIXELS: fail(413,'payload_too_large') + im.verify() + except Problem: raise + except (UnidentifiedImageError,OSError,ValueError): fail(415,'unsupported_media_type') + actual={'PNG':'image/png','JPEG':'image/jpeg'}.get(fmt) + if actual!=request.mimetype: fail(415,'unsupported_media_type') + ident_att=uuid.uuid4(); key=str(ident)+'/'+str(ident_att) + digest=hashlib.sha256(raw).hexdigest() + try: + s3.put_object(Bucket=bucket,Key=key,Body=raw,ContentType=actual,Metadata={'sha256':digest}) + row=c.execute("INSERT INTO attachments(id,chat_id,owner_id,object_key,filename,content_type,size_bytes,sha256,status) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,'ready') RETURNING *",(ident_att,ident,who,key,filename,actual,len(raw),digest)).fetchone() + except Exception: + try: s3.delete_object(Bucket=bucket,Key=key) + except Exception: app.logger.warning('attachment compensation deferred') + if isinstance(__import__('sys').exc_info()[1],psycopg.Error): raise + fail(503,'unavailable') + return attachment_json(row),201 + if path.startswith('attachments/'): + bits=path.split('/') + if len(bits) not in (2,3): fail(404,'not_found') + aid=uid(bits[1]) + row=c.execute('SELECT a.* FROM attachments a JOIN members m ON m.chat_id=a.chat_id WHERE a.id=%s AND m.user_id=%s',(aid,who)).fetchone() + if not row: fail(404,'not_found') + if len(bits)==2 and request.method=='GET': return attachment_json(row) + if len(bits)==3 and bits[2]=='content' and request.method=='GET': + try: obj=s3.get_object(Bucket=bucket,Key=row['object_key']); data=obj['Body'].read(MAX_UPLOAD+1) + except Exception: fail(503,'unavailable') + if len(data)>MAX_UPLOAD or hashlib.sha256(data).hexdigest()!=row['sha256']: fail(503,'unavailable') + disposition='attachment; filename="attachment"; filename*=UTF-8\'\''+quote(row['filename'],safe='') + return app.response_class(data,200,mimetype=row['content_type'],headers={'Content-Disposition':disposition}) + fail(404,'not_found') + +def attachment_json(row): + stamp=row['created_at'].isoformat().replace('+00:00','Z') + return {'id':str(row['id']),'chat_id':str(row['chat_id']),'owner_id':str(row['owner_id']),'filename':row['filename'],'content_type':row['content_type'],'size_bytes':row['size_bytes'],'sha256':row['sha256'].strip(),'status':'ready','variants':[],'error_code':None,'created_at':stamp,'updated_at':row.get('updated_at',row['created_at']).isoformat().replace('+00:00','Z')} diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..ec8eeae4 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,18 @@ +import os +from pathlib import Path +import psycopg + +def setting(name): + file = os.getenv(name + '_FILE') + return Path(file).read_text().strip() if file else os.environ[name] + +def migrate(): + with psycopg.connect(setting('DATABASE_URL'), connect_timeout=3) as c: + c.execute('SELECT pg_advisory_xact_lock(202602)') + c.execute('CREATE TABLE IF NOT EXISTS schema_migrations(version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())') + for p in sorted(Path('migrations').glob('*.sql')): + if not c.execute('SELECT 1 FROM schema_migrations WHERE version=%s',(p.name,)).fetchone(): + c.execute(p.read_text()) + c.execute('INSERT INTO schema_migrations(version) VALUES (%s)',(p.name,)) +if __name__ == '__main__': + migrate() diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..cf56c843 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,101 @@ +name: mtusi_lab4_solution +x-api: &api + build: . + image: mtusi-lab4-api:local + environment: + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id + S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key + S3_ENDPOINT: http://rustfs:9000 + S3_REGION: us-east-1 + S3_BUCKET: messenger-attachments + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + MAX_UPLOAD_BYTES: 10485760 + MAX_IMAGE_PIXELS: 40000000 + secrets: [database_url, cache_url, s3_access_key_id, s3_secret_access_key] + restart: unless-stopped + mem_limit: 512m + cpus: 0.75 +services: + postgres: + image: postgres:16.10-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/db_password + secrets: [db_password] + volumes: [pgdata:/var/lib/postgresql/data] + healthcheck: + test: [CMD-SHELL, pg_isready -U messenger -d messenger] + interval: 2s + timeout: 2s + retries: 30 + redis: + image: redis:7.4.6-alpine + command: [redis-server, --maxmemory, 64mb, --maxmemory-policy, allkeys-lru] + healthcheck: + test: [CMD, redis-cli, ping] + interval: 2s + timeout: 1s + retries: 20 + rustfs: + image: rustfs/rustfs:1.0.3-glibc + command: [/data] + environment: + RUSTFS_ACCESS_KEY_FILE: /run/secrets/rustfs_root_user + RUSTFS_SECRET_KEY_FILE: /run/secrets/rustfs_root_password + RUSTFS_CONSOLE_ENABLE: 'false' + RUSTFS_ADDRESS: ':9000' + secrets: [rustfs_root_user, rustfs_root_password] + volumes: [s3data:/data] + expose: ['9000'] + healthcheck: + test: [CMD, curl, -f, http://127.0.0.1:9000/health] + interval: 2s + timeout: 2s + retries: 30 + bucket-bootstrap: + image: rustfs/rc:v0.1.37 + depends_on: + rustfs: {condition: service_healthy} + entrypoint: [/bin/sh, /bootstrap-rustfs.sh] + volumes: ['./infra/rustfs-policy.json:/policy.json:ro', './infra/bootstrap-rustfs.sh:/bootstrap-rustfs.sh:ro'] + secrets: [rustfs_root_user, rustfs_root_password, s3_access_key_id, s3_secret_access_key] + restart: 'no' + migrate: + <<: *api + command: [python, -m, app.migrate] + restart: 'no' + depends_on: + postgres: {condition: service_healthy} + api: + <<: *api + command: [gunicorn, --bind, 0.0.0.0:8080, --workers, '1', --threads, '2', --timeout, '35', --graceful-timeout, '5', app.main:app] + scale: ${API_REPLICAS:-2} + depends_on: + migrate: {condition: service_completed_successfully} + redis: {condition: service_healthy} + bucket-bootstrap: {condition: service_completed_successfully} + healthcheck: + test: [CMD, python, -c, "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready', timeout=3)"] + interval: 2s + timeout: 4s + retries: 3 + lb: + image: haproxy:3.0.11-alpine + ports: ['127.0.0.1:8080:8080'] + volumes: ['./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro'] + depends_on: + api: {condition: service_healthy} +volumes: + pgdata: + s3data: +secrets: + db_password: {file: ./secrets/db_password} + database_url: {file: ./secrets/database_url} + cache_url: {file: ./secrets/cache_url} + rustfs_root_user: {file: ./secrets/rustfs_root_user} + rustfs_root_password: {file: ./secrets/rustfs_root_password} + s3_access_key_id: {file: ./secrets/s3_access_key_id} + s3_secret_access_key: {file: ./secrets/s3_secret_access_key} diff --git a/evidence/reconcile-experiment.json b/evidence/reconcile-experiment.json new file mode 100644 index 00000000..93049c87 --- /dev/null +++ b/evidence/reconcile-experiment.json @@ -0,0 +1,83 @@ +{ + "prefix": "reconcile-experiment-b33e31227dec426289f902db68dcaad5/", + "faults_injected": { + "missing_metadata_object": "reconcile-experiment-b33e31227dec426289f902db68dcaad5/missing.png", + "unreferenced_s3_object": "reconcile-experiment-b33e31227dec426289f902db68dcaad5/orphan.bin" + }, + "dry_run": { + "mode": "dry-run", + "bucket": "messenger-attachments", + "prefix": "reconcile-experiment-b33e31227dec426289f902db68dcaad5/", + "db_rows": 1, + "s3_objects": 1, + "missing_objects": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/missing.png" + ], + "orphan_objects": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/orphan.bin" + ], + "eligible_orphans": [], + "deleted_objects": [], + "grace_seconds": 86400, + "elapsed_seconds": 0.0856, + "safe_policy": "missing referenced objects are reported only; only unreferenced objects older than grace can be deleted" + }, + "fresh_orphan_apply": { + "mode": "apply", + "bucket": "messenger-attachments", + "prefix": "reconcile-experiment-b33e31227dec426289f902db68dcaad5/", + "db_rows": 1, + "s3_objects": 1, + "missing_objects": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/missing.png" + ], + "orphan_objects": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/orphan.bin" + ], + "eligible_orphans": [], + "deleted_objects": [], + "grace_seconds": 3600, + "elapsed_seconds": 0.0868, + "safe_policy": "missing referenced objects are reported only; only unreferenced objects older than grace can be deleted" + }, + "aged_orphan_apply": { + "mode": "apply", + "bucket": "messenger-attachments", + "prefix": "reconcile-experiment-b33e31227dec426289f902db68dcaad5/", + "db_rows": 1, + "s3_objects": 1, + "missing_objects": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/missing.png" + ], + "orphan_objects": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/orphan.bin" + ], + "eligible_orphans": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/orphan.bin" + ], + "deleted_objects": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/orphan.bin" + ], + "grace_seconds": 1, + "elapsed_seconds": 0.1185, + "safe_policy": "missing referenced objects are reported only; only unreferenced objects older than grace can be deleted" + }, + "repeat_dry_run": { + "mode": "dry-run", + "bucket": "messenger-attachments", + "prefix": "reconcile-experiment-b33e31227dec426289f902db68dcaad5/", + "db_rows": 1, + "s3_objects": 0, + "missing_objects": [ + "reconcile-experiment-b33e31227dec426289f902db68dcaad5/missing.png" + ], + "orphan_objects": [], + "eligible_orphans": [], + "deleted_objects": [], + "grace_seconds": 1, + "elapsed_seconds": 0.0884, + "safe_policy": "missing referenced objects are reported only; only unreferenced objects older than grace can be deleted" + }, + "sentinel_attachment_preserved": true, + "sentinel_sha256": "99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75" +} diff --git a/evidence/reconcile-inventory.json b/evidence/reconcile-inventory.json new file mode 100644 index 00000000..d982ce8f --- /dev/null +++ b/evidence/reconcile-inventory.json @@ -0,0 +1,14 @@ +{ + "mode": "dry-run", + "bucket": "messenger-attachments", + "prefix": null, + "db_rows": 424, + "s3_objects": 424, + "missing_objects": [], + "orphan_objects": [], + "eligible_orphans": [], + "deleted_objects": [], + "grace_seconds": 86400, + "elapsed_seconds": 0.1364, + "safe_policy": "missing referenced objects are reported only; only unreferenced objects older than grace can be deleted" +} diff --git a/evidence/runtime-checks.json b/evidence/runtime-checks.json new file mode 100644 index 00000000..e6298a51 --- /dev/null +++ b/evidence/runtime-checks.json @@ -0,0 +1,120 @@ +{ + "checked_at": "2026-11-06", + "environment": { + "docker_engine": "29.8.0", + "docker_os": "linux/aarch64 via Docker Desktop", + "docker_vm_cpus": 10, + "docker_vm_memory_bytes": 8319504384, + "compose": "v2; docker compose config --quiet passed" + }, + "services": { + "api": { + "replicas": 2, + "status": "healthy", + "container_memory_limit_mib": 512, + "cpu_limit": 0.75, + "gunicorn_threads_per_replica": 2 + }, + "postgres": { + "image": "postgres:16.10-alpine", + "status": "healthy", + "persistent_volume": "pgdata" + }, + "redis": { + "image": "redis:7.4.6-alpine", + "status": "healthy" + }, + "rustfs": { + "image": "rustfs/rustfs:1.0.3-glibc", + "status": "healthy", + "persistent_volume": "s3data", + "published_host_ports": false, + "console_enabled": false + }, + "haproxy": { + "image": "haproxy:3.0.11-alpine", + "status": "running", + "published": "127.0.0.1:8080" + } + }, + "checks": [ + { + "name": "make check", + "result": "PASS" + }, + { + "name": "public lab4 smoke", + "result": "PASS", + "repeat_count": 3 + }, + { + "name": "negative attachments", + "result": "PASS", + "cases": [ + "real PNG upload/download", + "real JPEG upload/download byte-for-byte", + "unsafe filename 400", + "corrupt PNG 415", + "spoofed MIME 415", + "10 MiB plus one byte 413", + "40,972,801 decoded pixels 413", + "outsider metadata/content 404", + "cross-chat attachment reference 404" + ], + "repeat_count": 2 + }, + { + "name": "persistence hook", + "result": "PASS", + "observed": "Full Compose stack and stores restarted with volumes retained; same session, chat, messages and original attachment survived" + }, + { + "name": "API failover hook", + "result": "PASS", + "replicas_before": 2, + "successful_writes": 127, + "transition_failures": 2, + "first_recovery_seconds": 1.273, + "confirmed_messages_and_attachment_preserved": true + }, + { + "name": "RustFS outage", + "result": "PASS", + "upload_response": 503, + "metadata_rows_left_by_failed_upload": 0, + "RustFS_recovered": true + }, + { + "name": "unsigned S3 object GET", + "result": "PASS", + "response": "AccessDenied" + }, + { + "name": "API credentials outside assigned bucket role", + "result": "PASS", + "create_bucket_response": "AccessDenied" + }, + { + "name": "track 2 orphan/missing reconciliation", + "result": "PASS", + "evidence": "evidence/reconcile-experiment.json" + }, + { + "name": "full inventory dry-run", + "result": "PASS", + "db_rows": 424, + "s3_objects": 424, + "missing": 0, + "orphans": 0, + "elapsed_seconds": 0.1364 + }, + { + "name": "10-way upload load", + "result": "PASS", + "evidence": "evidence/upload-load.json", + "small_uploads": 100, + "large_uploads": 30, + "failures": 0 + } + ] +} diff --git a/evidence/upload-load.json b/evidence/upload-load.json new file mode 100644 index 00000000..1f7f815b --- /dev/null +++ b/evidence/upload-load.json @@ -0,0 +1,56 @@ +{ + "date_utc": "2026-11-06T13:30:09.598678+00:00", + "concurrency": 10, + "profiles": [ + { + "name": "small", + "dimensions": [ + 512, + 512 + ], + "pixels": 262144, + "payload_bytes": 787247, + "sha256": "30294897b5ec4a2f2ae4d833a164f82fc6f488e5c329b2a64ce37e3a480da11a", + "uploads_per_worker": 10, + "successes": 100, + "failures": 0, + "elapsed_seconds": 1.294, + "successful_rps": 77.277, + "latency_ms": { + "p50": 50.69, + "p95": 87.39, + "p99": 105.97 + }, + "api_peak_memory_mib_sampled": {}, + "sampling_interval_seconds": 1, + "sample_count": 0 + }, + { + "name": "large", + "dimensions": [ + 2048, + 1536 + ], + "pixels": 3145728, + "payload_bytes": 9441653, + "sha256": "38f8c22db1c1af1a9d00b9bccc6510492f25ec365a1ffc49d506a4df55abb0da", + "uploads_per_worker": 3, + "successes": 30, + "failures": 0, + "elapsed_seconds": 1.933, + "successful_rps": 15.519, + "latency_ms": { + "p50": 328.39, + "p95": 476.86, + "p99": 599.46 + }, + "api_peak_memory_mib_sampled": { + "mtusi_lab4_solution-api-2": 133.5, + "mtusi_lab4_solution-api-1": 135.9 + }, + "sampling_interval_seconds": 1, + "sample_count": 2 + } + ], + "method": "10 workers start together; small profile repeats 10 times per worker and large 3 times; same generated PNG payload per profile; Docker stats streamed in a pseudo-terminal at Docker default cadence (~1s); no retries" +} diff --git a/infra/README.md b/infra/README.md index 5a39e862..9d38cd81 100644 --- a/infra/README.md +++ b/infra/README.md @@ -1,7 +1,5 @@ -# Инфраструктура студента +# Инфраструктура лабораторной 4 -Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли. +Запускаемый Compose находится в корне репозитория. Выбран RustFS: `rustfs/rustfs:1.0.3-glibc`, с persistent volume `s3data`; S3 доступен только во внутренней сети. Console выключена. Bucket `messenger-attachments` и отдельный API IAM user создаются повторяемым `bucket-bootstrap` (`infra/bootstrap-rustfs.sh`) с policy из `infra/rustfs-policy.json`. -В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд. - -Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику. +PostgreSQL использует volume `pgdata` и схему из `migrations/`; API подключается по внутренней сети, HAProxy опубликован только на `127.0.0.1:8080`. Все пароли/ключи создаются `scripts/bootstrap.py`, передаются Compose secrets и не хранятся в репозитории. Версии образов и readiness hooks зафиксированы в корневом `compose.yaml` и сопоставлены в `REPORT.md`. diff --git a/infra/bootstrap-rustfs.sh b/infra/bootstrap-rustfs.sh new file mode 100755 index 00000000..8005d747 --- /dev/null +++ b/infra/bootstrap-rustfs.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +root_user=$(cat /run/secrets/rustfs_root_user) +root_password=$(cat /run/secrets/rustfs_root_password) +app_key=$(cat /run/secrets/s3_access_key_id) +app_secret=$(cat /run/secrets/s3_secret_access_key) +rc alias set local http://rustfs:9000 "$root_user" "$root_password" +if ! rc bucket list local/ | grep -q 'messenger-attachments'; then + rc bucket create local/messenger-attachments +fi +if ! rc admin policy info local messenger-objects >/dev/null 2>&1; then + rc admin policy create local messenger-objects /policy.json +fi +if ! rc admin user info local "$app_key" >/dev/null 2>&1; then + rc admin user add local "$app_key" "$app_secret" +fi +rc admin policy attach local messenger-objects --user "$app_key" diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..367b71d2 --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,28 @@ +global + log stdout format raw local0 + maxconn 1024 +defaults + log global + mode http + timeout connect 500ms + timeout client 30s + timeout server 30s + timeout check 1s + retries 0 +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 2 + timeout resolve 1s + timeout retry 1s + hold valid 1s + hold obsolete 1s +frontend public + bind *:8080 + default_backend replicas +backend replicas + balance roundrobin + option http-server-close + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 1s fastinter 500ms downinter 1s fall 2 rise 1 resolvers docker init-addr none + server-template api 8 api:8080 check diff --git a/infra/rustfs-policy.json b/infra/rustfs-policy.json new file mode 100644 index 00000000..21982c00 --- /dev/null +++ b/infra/rustfs-policy.json @@ -0,0 +1 @@ +{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:GetObject","s3:PutObject","s3:DeleteObject"],"Resource":["arn:aws:s3:::messenger-attachments/*"]},{"Effect":"Allow","Action":["s3:ListBucket"],"Resource":["arn:aws:s3:::messenger-attachments"]}]} diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..1126d091 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,20 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, username text NOT NULL UNIQUE CHECK(username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK(length(btrim(display_name))>0 AND length(display_name)<=100), + password_hash text NOT NULL, created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chats (id uuid PRIMARY KEY, title text NOT NULL CHECK(length(btrim(title))>0 AND length(title)<=100), created_at timestamptz NOT NULL DEFAULT clock_timestamp()); +CREATE TABLE members (chat_id uuid REFERENCES chats ON DELETE CASCADE, user_id uuid REFERENCES users, PRIMARY KEY(chat_id,user_id)); +CREATE INDEX members_user ON members(user_id,chat_id); +CREATE TABLE attachments ( + id uuid PRIMARY KEY, chat_id uuid NOT NULL REFERENCES chats, owner_id uuid NOT NULL REFERENCES users, + object_key text NOT NULL UNIQUE, filename text NOT NULL, content_type text NOT NULL, + size_bytes bigint NOT NULL, sha256 char(64) NOT NULL, status text NOT NULL CHECK(status IN ('ready')), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), updated_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE INDEX attachments_chat ON attachments(chat_id,id); +CREATE TABLE messages (id uuid PRIMARY KEY, chat_id uuid NOT NULL REFERENCES chats, sender_id uuid NOT NULL REFERENCES users, text text NOT NULL CHECK(length(text)<=4000), created_at timestamptz NOT NULL DEFAULT clock_timestamp()); +CREATE TABLE message_attachments (message_id uuid REFERENCES messages ON DELETE CASCADE, attachment_id uuid REFERENCES attachments, position smallint NOT NULL, PRIMARY KEY(message_id,attachment_id), UNIQUE(message_id,position)); +CREATE INDEX messages_history ON messages(chat_id,created_at,id); +CREATE TABLE sessions (token_hash text PRIMARY KEY, user_id uuid NOT NULL REFERENCES users, expires_at timestamptz NOT NULL); +CREATE INDEX sessions_expiry ON sessions(expires_at); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..3fa0f8d7 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,6 @@ +CREATE TABLE idempotency ( + user_id uuid NOT NULL REFERENCES users, chat_id uuid NOT NULL REFERENCES chats, + key varchar(128) NOT NULL, body text NOT NULL, response jsonb NOT NULL, + expires_at timestamptz NOT NULL, PRIMARY KEY(user_id,chat_id,key) +); +CREATE INDEX idempotency_expiry ON idempotency(expires_at); diff --git a/requirements.lock b/requirements.lock new file mode 100644 index 00000000..9ecf9348 --- /dev/null +++ b/requirements.lock @@ -0,0 +1,26 @@ +argon2-cffi==25.1.0 +argon2-cffi-bindings==26.1.0 +blinker==1.9.0 +cffi==2.1.1 +click==8.5.0 +Flask==3.1.2 +gunicorn==23.0.0 +itsdangerous==2.2.0 +Jinja2==3.1.6 +MarkupSafe==3.0.4 +packaging==26.3 +psycopg==3.2.10 +psycopg-binary==3.2.10 +psycopg-pool==3.3.3 +pycparser==3.11 +redis==6.4.0 +typing_extensions==4.16.0 +Werkzeug==3.1.9 +boto3==1.40.55 +botocore==1.40.55 +jmespath==1.0.1 +Pillow==11.3.0 +python-dateutil==2.9.0.post0 +s3transfer==0.14.0 +six==1.17.0 +urllib3==2.5.0 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..7a447dca --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +Flask==3.1.2 +gunicorn==23.0.0 +psycopg[binary,pool]==3.2.10 +redis==6.4.0 +argon2-cffi==25.1.0 +boto3==1.40.55 +Pillow==11.3.0 diff --git a/scripts/bootstrap.py b/scripts/bootstrap.py new file mode 100755 index 00000000..cde86475 --- /dev/null +++ b/scripts/bootstrap.py @@ -0,0 +1,21 @@ +#!/usr/bin/env python3 +"""Create local-only secret files once; do not print their values.""" +from pathlib import Path +import secrets +root=Path(__file__).resolve().parents[1] +d=root/'secrets'; d.mkdir(mode=0o700,exist_ok=True); d.chmod(0o700) +def ensure(name,value): + p=d/name + if not p.exists(): p.write_text(value) + p.chmod(0o600) +ensure('db_password',secrets.token_urlsafe(32)) +ensure('rustfs_root_user','RUSTFSROOT') +ensure('rustfs_root_password',secrets.token_urlsafe(32)) +ensure('s3_access_key_id','messengerapi') +ensure('s3_secret_access_key',secrets.token_urlsafe(40)) +p=d/'database_url'; ensure('database_url','postgresql://messenger:'+ (d/'db_password').read_text().strip()+'@postgres:5432/messenger') +ensure('cache_url','redis://redis:6379/0') +env=root/'.env' +if not env.exists(): env.write_text('API_REPLICAS=2\nSESSION_TTL_SECONDS=3600\n') +env.chmod(0o600) +print('Local secrets created or preserved; values hidden.') diff --git a/scripts/reconcile.py b/scripts/reconcile.py new file mode 100755 index 00000000..3cacb72d --- /dev/null +++ b/scripts/reconcile.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +"""Safe S3/PostgreSQL attachment inventory. Dry-run unless --apply is specified.""" +import argparse +import datetime as dt +import json +import os +from pathlib import Path +import sys +import time +import boto3 +from botocore.config import Config +import psycopg +from psycopg.rows import dict_row +sys.path.insert(0,str(Path(__file__).resolve().parents[1])) +from app.migrate import setting + +def main(): + p=argparse.ArgumentParser(description=__doc__) + p.add_argument('--apply',action='store_true',help='delete only unreferenced S3 objects older than the grace period') + p.add_argument('--grace-seconds',type=int,default=86400) + p.add_argument('--allow-short-grace',action='store_true',help='test-only override; use only with a dedicated --prefix') + p.add_argument('--prefix',default='',help='restrict the scan and repair to one S3 prefix') + a=p.parse_args() + if a.grace_seconds<3600 and not (a.allow_short_grace and a.prefix): p.error('grace period must be at least 3600 seconds unless test-only override and a prefix are both supplied') + endpoint=os.getenv('S3_ENDPOINT','http://rustfs:9000'); bucket=os.getenv('S3_BUCKET','messenger-attachments') + started=time.monotonic() + key=setting('S3_ACCESS_KEY_ID'); secret=setting('S3_SECRET_ACCESS_KEY') + s3=boto3.client('s3',endpoint_url=endpoint,region_name=os.getenv('S3_REGION','us-east-1'),aws_access_key_id=key,aws_secret_access_key=secret,config=Config(connect_timeout=3,read_timeout=10,retries={'max_attempts':2})) + with psycopg.connect(setting('DATABASE_URL'),row_factory=dict_row,connect_timeout=3) as db: + if a.prefix: + rows=db.execute('SELECT id,object_key,created_at FROM attachments WHERE object_key LIKE %s',(a.prefix.replace('\\','\\\\').replace('%','\\%').replace('_','\\_')+'%',)).fetchall() + else: + rows=db.execute('SELECT id,object_key,created_at FROM attachments').fetchall() + by_key={r['object_key']:r for r in rows} + objects=[]; token=None + while True: + args={'Bucket':bucket,'MaxKeys':1000} + if a.prefix: args['Prefix']=a.prefix + if token: args['ContinuationToken']=token + page=s3.list_objects_v2(**args) + objects.extend(page.get('Contents',[])) + if not page.get('IsTruncated'): break + token=page['NextContinuationToken'] + object_keys={o['Key'] for o in objects} + missing=sorted(k for k in by_key if k not in object_keys) + now=dt.datetime.now(dt.timezone.utc); cutoff=now-dt.timedelta(seconds=a.grace_seconds) + orphan=[o for o in objects if o['Key'] not in by_key] + eligible=[o for o in orphan if o['LastModified']&2 +exit 1 diff --git a/tests/attachments_negative.py b/tests/attachments_negative.py new file mode 100755 index 00000000..7e7916a7 --- /dev/null +++ b/tests/attachments_negative.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +"""Negative attachment authorization and validation checks against a running lab4 API.""" +from urllib.parse import quote, urlsplit +from client import Client, LAB, arguments, check, run +from pathlib import Path +from uuid import uuid4 +import http.client, json, ssl, struct, zlib + +def check_oversize_rejected(base_url, actor, path): + parts=urlsplit(base_url or 'http://localhost:8080') + conn_cls=http.client.HTTPSConnection if parts.scheme=='https' else http.client.HTTPConnection + kwargs={'timeout':120} + if parts.scheme=='https': kwargs['context']=ssl.create_default_context() + conn=conn_cls(parts.hostname,parts.port,**kwargs) + target=path + conn.putrequest('POST',target) + conn.putheader('Host',parts.netloc) + conn.putheader('Accept','application/json') + conn.putheader('Authorization','Bearer '+actor['token']) + conn.putheader('Content-Type','image/png') + conn.putheader('Content-Length',str(10485761)) + conn.putheader('Connection','close') + conn.endheaders() + response=conn.getresponse(); payload=json.loads(response.read()) + check(response.status==413,'10 MiB plus one byte was not rejected with 413') + check(response.getheader('X-Request-Id')==payload['error']['request_id'],'oversize response request_id mismatch') + conn.close() + +def pixel_limit_fixture(width=6401,height=6401): + def chunk(tag,data): return struct.pack('>I',len(data))+tag+data+struct.pack('>I',zlib.crc32(tag+data)&0xffffffff) + encoder=zlib.compressobj(1); compressed=bytearray(); row=b'\0'+bytes(width*3) + for _ in range(height): compressed.extend(encoder.compress(row)) + compressed.extend(encoder.flush()) + header=struct.pack('>IIBBBBB',width,height,8,2,0,0,0) + return b'\x89PNG\r\n\x1a\n'+chunk(b'IHDR',header)+chunk(b'IDAT',compressed)+chunk(b'IEND',b'') + +def main(): + a=arguments('Attachment negative checks; creates synthetic users, chats, messages') + check(LAB==4,'this scenario targets synchronous lab4 attachments') + c=Client(a.base_url,a.ca_file,timeout=120); alice,bob,eve,chat=c.bootstrap() + base='/api/v1/chats/'+chat['id']+'/attachments?filename=' + c.call('POST',base+quote('../bad.png'),400,actor=alice,raw=b'bad',headers={'Content-Type':'image/png'}) + fixture=(Path(__file__).parent/'fixtures/sample.png').read_bytes() + for content,mime,expected,label in [(b'not an image','image/png',415,'corrupt bytes'),(fixture,'image/jpeg',415,'spoofed MIME')]: + print('checking '+label,flush=True) + r=c.call('POST',base+quote('bad.png'),expected,actor=alice,raw=content,headers={'Content-Type':mime}) + print('checking too large',flush=True) + check_oversize_rejected(a.base_url,alice,base+quote('bad.png')) + print('checking too many pixels',flush=True) + c.call('POST',base+quote('bad.png'),413,actor=alice,raw=pixel_limit_fixture(),headers={'Content-Type':'image/png'}) + # Upload real file, then verify outsider and wrong-chat references are hidden. + print('uploading valid image',flush=True) + att=c.call('POST',base+quote('sample.png'),201,actor=alice,raw=fixture,headers={'Content-Type':'image/png'},schema='Attachment')['json'] + jpeg=(Path(__file__).parent/'fixtures/sample.jpg').read_bytes() + jpeg_att=c.call('POST',base+quote('sample.jpg'),201,actor=alice,raw=jpeg,headers={'Content-Type':'image/jpeg'},schema='Attachment')['json'] + downloaded=c.call('GET','/api/v1/attachments/'+jpeg_att['id']+'/content',actor=bob) + check(downloaded['bytes']==jpeg and jpeg_att['content_type']=='image/jpeg','real JPEG round-trip mismatch') + c.call('GET','/api/v1/attachments/'+att['id'],404,actor=eve) + c.call('GET','/api/v1/attachments/'+att['id']+'/content',404,actor=eve) + other=c.call('POST','/api/v1/chats',201,actor=alice,body={'title':'Другой чат','member_ids':[alice['id'],bob['id']]},schema='Chat')['json'] + c.call('POST','/api/v1/chats/'+other['id']+'/messages',404,actor=bob,body={'text':'','attachment_ids':[att['id']]},headers={'Idempotency-Key':uuid4().hex}) + print('PASS: real PNG/JPEG, pixel/byte limits, corrupt image, MIME spoof, outsider access, and cross-chat binding checked') +if __name__=='__main__': run(main) diff --git a/tests/client.py b/tests/client.py index f0499a29..90476a49 100644 --- a/tests/client.py +++ b/tests/client.py @@ -122,7 +122,9 @@ class Client: response = error except (urllib.error.URLError,TimeoutError,OSError) as exc: # Do not print URL query, headers, request body, or credentials. - raise Failure(method + ' ' + path.split('?')[0] + ': connection/TLS failure (' + type(exc).__name__ + ')') from None + reason=getattr(exc,'reason',None) + reason_type=type(reason).__name__ if reason is not None else type(exc).__name__ + raise Failure(method + ' ' + path.split('?')[0] + ': connection/TLS failure (' + reason_type + ')') from None with response: status = response.code rh = response.headers diff --git a/tests/fixtures/README.md b/tests/fixtures/README.md index 9ed52c30..55a4c37c 100644 --- a/tests/fixtures/README.md +++ b/tests/fixtures/README.md @@ -6,4 +6,6 @@ sample.png: RGB PNG 320×200, создан программно специаль - SHA-256: `99ea7533c441f79cd630d15ce4d58d1ec4e06f6f0efb3b77a5c088305cd1bd75`. - Обязательный thumbnail с lab5: JPEG 256×160. +`sample.jpg` — JPEG 320×200, полученный преобразованием этой же синтетической картинки; SHA-256: `88585921771cc8ab0afac847728ab899c418c92d8d5ee2cdfeeda8b84a3c61de`. Он нужен для проверки реального JPEG upload/download в lab4. + Проверяющий читает SHA-256 оригинала, metadata вариантов и реальные размеры JPEG, а не только JSON-обещание сервера. Повреждённые, oversized и decompression-bomb fixtures для собственного negative suite создавайте отдельно; не храните огромные файлы в Git. diff --git a/tests/fixtures/sample.jpg b/tests/fixtures/sample.jpg new file mode 100644 index 00000000..2b89dbf1 Binary files /dev/null and b/tests/fixtures/sample.jpg differ diff --git a/tests/s3_unavailable.py b/tests/s3_unavailable.py new file mode 100755 index 00000000..51cc4ac5 --- /dev/null +++ b/tests/s3_unavailable.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Stop RustFS briefly; confirm upload fails cleanly without DB metadata and recover it.""" +import subprocess, sys, time +from pathlib import Path +from client import Client, LAB, arguments, check, run +ROOT=Path(__file__).resolve().parents[1] +def compose(*args): subprocess.run(['docker','compose',*args],cwd=ROOT,check=True,stdout=subprocess.DEVNULL) +def attachment_count(): + code="from app.main import pool\nwith pool.connection() as c: print(c.execute('SELECT count(*) AS n FROM attachments').fetchone()['n'])" + # A dedicated short-lived process reads the count; no values other than the integer are emitted. + out=subprocess.run(['docker','compose','exec','-T','api','python','-c',code],cwd=ROOT,check=True,capture_output=True,text=True).stdout.strip() + return int(out.splitlines()[-1]) +def main(): + a=arguments('RustFS outage check; briefly stops the local RustFS service') + check(LAB==4,'scenario targets lab4') + c=Client(a.base_url,a.ca_file,timeout=10); alice,bob,eve,chat=c.bootstrap() + raw=(ROOT/'tests/fixtures/sample.png').read_bytes() + before=attachment_count(); stopped=False + try: + compose('stop','rustfs'); stopped=True + c.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=outage.png',503,actor=alice,raw=raw,headers={'Content-Type':'image/png'}) + finally: + if stopped: compose('start','rustfs') + deadline=time.monotonic()+60 + while True: + try: + c.call('GET','/health/ready') + break + except Exception: + check(time.monotonic()I',len(data))+tag+data+struct.pack('>I',zlib.crc32(tag+data)&0xffffffff) + return b'\x89PNG\r\n\x1a\n'+chunk(b'IHDR',struct.pack('>IIBBBBB',width,height,8,2,0,0,0))+chunk(b'IDAT',zlib.compress(bytes(raw),1))+chunk(b'IEND',b'') + +STATS_RE=re.compile(r'(mtusi_lab4_solution-api-[^|\s]+)\|([\d.]+)(GiB|MiB|KiB|B) / [^|\s]+\|([\d.]+)%') +def parse_stats_text(text): + vals={} + for name,number,unit,cpu in STATS_RE.findall(text): + scale={'GiB':1024,'MiB':1,'KiB':1/1024,'B':1/(1024*1024)}[unit] + vals[name]={'memory_mib':float(number)*scale,'cpu_percent':float(cpu)} + return vals + +def main(): + a=arguments('Synthetic image upload experiment with sampled Docker API memory') + check(LAB==4,'experiment targets synchronous lab4 uploads') + c=Client(a.base_url,a.ca_file,timeout=30); alice,bob,eve,chat=c.bootstrap() + profiles=[('small',512,512),('large',2048,1536)] + result={'date_utc':datetime.now(timezone.utc).isoformat(),'concurrency':10,'profiles':[],'method':'10 workers start together; small profile repeats 10 times per worker and large 3 times; same generated PNG payload per profile; Docker stats streamed in a pseudo-terminal at Docker default cadence (~1s); no retries'} + for name,w,h in profiles: + repetitions=10 if name=='small' else 3 + payload=png_noise(w,h,20261106+w) + barrier=threading.Barrier(10); samples=[]; stop=threading.Event() + master,slave=pty.openpty() + monitor_process=subprocess.Popen(['docker','stats','--format','{{.Name}}|{{.MemUsage}}|{{.CPUPerc}}'],stdin=slave,stdout=slave,stderr=slave,close_fds=True) + os.close(slave) + def monitor(): + buf='' + while not stop.is_set(): + try: chunk=os.read(master,8192) + except OSError: break + if not chunk: break + buf=(buf+chunk.decode('utf-8','ignore'))[-16384:] + point=parse_stats_text(buf) + if point: samples.append(point) + mt=threading.Thread(target=monitor,daemon=True); mt.start() + def upload(i): + local=Client(a.base_url,a.ca_file,timeout=30); barrier.wait(); time.sleep(.2); out=[] + for j in range(repetitions): + t=time.monotonic() + try: + local.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename='+name+'-'+str(i)+'-'+str(j)+'.png',201,actor=alice,raw=payload,headers={'Content-Type':'image/png'},schema='Attachment') + out.append({'ok':True,'latency_ms':(time.monotonic()-t)*1000}) + except Exception as e: + out.append({'ok':False,'error_type':type(e).__name__,'latency_ms':(time.monotonic()-t)*1000}) + return out + started=time.monotonic() + with ThreadPoolExecutor(max_workers=10) as pool: items=[item for group in pool.map(upload,range(10)) for item in group] + elapsed=time.monotonic()-started; stop.set(); monitor_process.terminate(); monitor_process.wait(timeout=3); mt.join(timeout=3); os.close(master) + lat=sorted(x['latency_ms'] for x in items if x['ok']) + peak={} + for snap in samples: + for service,m in snap.items(): peak[service]=max(peak.get(service,0),m['memory_mib']) + def pct(p): return round(lat[max(0,math.ceil(p*len(lat))-1)],2) if lat else None + result['profiles'].append({'name':name,'dimensions':[w,h],'pixels':w*h,'payload_bytes':len(payload),'sha256':hashlib.sha256(payload).hexdigest(),'uploads_per_worker':repetitions,'successes':sum(x['ok'] for x in items),'failures':sum(not x['ok'] for x in items),'elapsed_seconds':round(elapsed,3),'successful_rps':round(sum(x['ok'] for x in items)/elapsed,3),'latency_ms':{'p50':pct(.50),'p95':pct(.95),'p99':pct(.99)},'api_peak_memory_mib_sampled':peak,'sampling_interval_seconds':1,'sample_count':len(samples)}) + dest=Path('evidence/upload-load.json'); dest.parent.mkdir(parents=True,exist_ok=True); dest.write_text(json.dumps(result,indent=2)+'\n') + print(json.dumps(result,indent=2)) + check(all(x['failures']==0 and x['successes']==10*x['uploads_per_worker'] for x in result['profiles']),'one or more uploads failed') +if __name__=='__main__': run(main)