From 01ae369a4a434e808da345a84aa7ad5b254c8198 Mon Sep 17 00:00:00 2001 From: Lev4213 Date: Thu, 12 Nov 2026 22:56:12 +0300 Subject: [PATCH 1/3] Lab4: MinIO attachments --- .env.example | 15 +- Dockerfile | 20 ++ REPORT.md | 155 ++++++++- compose.yaml | 153 +++++++++ evidence/compose-ps.txt | Bin 0 -> 2014 bytes evidence/failover.txt | Bin 0 -> 596 bytes evidence/restart.txt | Bin 0 -> 380 bytes evidence/smoke.txt | Bin 0 -> 174 bytes infra/nginx.conf | 41 +++ migrations/001_init.sql | 44 +++ migrations/002_idempotency.sql | 9 + migrations/003_attachments.sql | 25 ++ requirements.txt | 8 + scripts/migrate.py | 15 + scripts/restart.cmd | 4 + scripts/restart.sh | 4 + scripts/stop-one.cmd | 12 + scripts/stop-one.sh | 14 + src/messenger/__init__.py | 0 src/messenger/app.py | 323 +++++++++++++++++++ src/messenger/cursors.py | 34 ++ src/messenger/db.py | 115 +++++++ src/messenger/errors.py | 45 +++ src/messenger/images.py | 68 ++++ src/messenger/models.py | 81 +++++ src/messenger/s3util.py | 113 +++++++ src/messenger/store.py | 559 +++++++++++++++++++++++++++++++++ src/messenger/tables.py | 102 ++++++ 28 files changed, 1937 insertions(+), 22 deletions(-) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 evidence/compose-ps.txt create mode 100644 evidence/failover.txt create mode 100644 evidence/restart.txt create mode 100644 evidence/smoke.txt create mode 100644 infra/nginx.conf create mode 100644 migrations/001_init.sql create mode 100644 migrations/002_idempotency.sql create mode 100644 migrations/003_attachments.sql create mode 100644 requirements.txt create mode 100644 scripts/migrate.py create mode 100644 scripts/restart.cmd create mode 100644 scripts/restart.sh create mode 100644 scripts/stop-one.cmd create mode 100644 scripts/stop-one.sh create mode 100644 src/messenger/__init__.py create mode 100644 src/messenger/app.py create mode 100644 src/messenger/cursors.py create mode 100644 src/messenger/db.py create mode 100644 src/messenger/errors.py create mode 100644 src/messenger/images.py create mode 100644 src/messenger/models.py create mode 100644 src/messenger/s3util.py create mode 100644 src/messenger/store.py create mode 100644 src/messenger/tables.py diff --git a/.env.example b/.env.example index d99d26a2..97599eca 100644 --- a/.env.example +++ b/.env.example @@ -1,20 +1,21 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. APP_HOST=0.0.0.0 APP_PORT=8080 +# Host publish port of the load balancer; change if 8080 is busy locally. +HOST_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 +DATABASE_URL=postgresql://messenger:messenger@postgres:5432/messenger +# DATABASE_URL_FILE=/run/secrets/database_url API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 S3_ENDPOINT=http://s3:9000 S3_REGION=us-east-1 S3_BUCKET=messenger-attachments -S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id -S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key +S3_ACCESS_KEY_ID=minioadmin +S3_SECRET_ACCESS_KEY=minioadmin +# S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id +# S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key MAX_UPLOAD_BYTES=10485760 MAX_IMAGE_PIXELS=40000000 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..26defa4a --- /dev/null +++ b/Dockerfile @@ -0,0 +1,20 @@ +FROM python:3.12.8-slim-bookworm + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY migrations/ ./migrations/ +COPY src/ ./src/ +COPY scripts/migrate.py ./scripts/migrate.py + +ENV PYTHONPATH=/app/src +ENV APP_HOST=0.0.0.0 +ENV APP_PORT=8080 +ENV APP_ENV=lab +ENV SESSION_TTL_SECONDS=3600 + +EXPOSE 8080 + +CMD ["sh", "-c", "exec uvicorn messenger.app:app --host ${APP_HOST} --port ${APP_PORT}"] diff --git a/REPORT.md b/REPORT.md index 9ad2b84f..047913ee 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,162 @@ # Отчёт — лабораторная 4 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Гадяцкий Л. Е., БПИ2302 +- Целевая оценка: 3 +- Commit/PR: solution/BPI2302-Gadiatskiy +- Использованные источники и библиотеки: + - контракт и семантика: `contracts/openapi.json`, `contracts/README.md`, `README.md`, `COURSE.md` + - перенос из lab3: FastAPI, PostgreSQL/сессии, SQLAlchemy, миграции, Nginx LB, идемпотентность + - runtime: FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, SQLAlchemy 2.0.36, psycopg 3.2.4, argon2-cffi 23.1.0, boto3 1.35.76, Pillow 11.0.0 + - PostgreSQL: `postgres:16-alpine`; LB: `nginx:1.27-alpine`; S3/MinIO: `alpine/minio:RELEASE.2025-10-15T17-29-55Z` +- Помощь ИИ использована при переносе lab3, частично для вложений/S3 и при заполнении отчёта. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Prerequisites:** Docker и Docker Compose. Python 3.9+ нужен только для публичных проверок (`make check` / `make test` / `tests/resilience.py`). Runtime приложения — внутри образа. + +**Версии:** +- API: базовый образ `python:3.12.8-slim-bookworm` → локальный `mtusi-messenger:lab4` +- PostgreSQL: `postgres:16-alpine` +- Nginx: `nginx:1.27-alpine` +- MinIO: `alpine/minio:RELEASE.2025-10-15T17-29-55Z` (community image; официальный `minio/minio` с Docker Hub недоступен) +- зависимости: `requirements.txt` + +**Конфигурация:** секретов в Git нет. Локальный `.env` создаётся из примера и не коммитится: + +```sh +cp .env.example .env +``` + +Соответствие `.env.example`: +- `APP_HOST` / `APP_PORT` — bind uvicorn внутри контейнеров API +- `HOST_PORT` — порт LB на host (по умолчанию 8080; если занят — например 8081) +- `APP_ENV` — среда запуска (`lab`) +- `SESSION_TTL_SECONDS` — TTL сессии (по умолчанию 3600; для обычного smoke ≥ 300) +- `SESSION_STORE=postgres` — сессии в PostgreSQL (общие для всех реплик) +- `DATABASE_URL` — строка подключения API/migrate к PostgreSQL в compose-сети + (приложение также поддерживает `DATABASE_URL_FILE`) +- `IDEMPOTENCY_TTL_SECONDS` — срок хранения идемпотентных записей (по умолчанию 86400) +- `API_REPLICAS=2` — в `compose.yaml` зафиксированы сервисы `api1` и `api2` +- `S3_ENDPOINT` / `S3_REGION` / `S3_BUCKET` — доступ API к MinIO в compose-сети +- `S3_ACCESS_KEY_ID` / `S3_SECRET_ACCESS_KEY` — учебные credentials MinIO (также `*_FILE`) +- `MAX_UPLOAD_BYTES=10485760`, `MAX_IMAGE_PIXELS=40000000` — лимиты загрузки + +Учебные credentials compose (`messenger` / `messenger`, MinIO `minioadmin` / `minioadmin`) только для локального синтетического стенда. + +**Сборка и запуск:** + +```sh +docker compose --env-file .env up -d --build +``` + +Миграции `migrations/*.sql` применяет one-shot сервис `migrate` до старта `api1`/`api2` (учёт в `schema_migrations`). Приватный bucket `S3_BUCKET` идемпотентно создаёт API при старте (`ensure_bucket`). Реплики API миграции SQL при старте не выполняют. + +Готовность через LB (подставьте свой `HOST_PORT`): + +```sh +curl -i http://127.0.0.1:8080/health/ready +``` + +Ожидается HTTP 200, тело `{"status":"ok"}`, заголовки `X-Request-Id` и `X-Instance-Id` (`api1` или `api2`). `/health/ready` требует доступности PostgreSQL и S3 (MinIO). + +**Публичный smoke** (при уже запущенном стенде): + +```sh +python tests/smoke.py --base-url http://127.0.0.1:8080 +# или: make test BASE_URL=http://127.0.0.1:8080 +``` + +**Проверка сохранности** (включая исходный файл вложения): + +```sh +# Unix: +chmod +x scripts/restart.sh +python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080 + +# Windows: +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8080 +``` + +Hook выполняет `docker compose --env-file .env restart` для `postgres`, `s3`, `api1`, `api2`, `lb` **без** удаления volumes (`down -v` не используется). + +**Проверка отказа одной API-реплики** (upload → stop обслужившей → download через другую): + +```sh +# Unix: +chmod +x scripts/stop-one.sh +python tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080 + +# Windows: +python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://127.0.0.1:8080 +``` + +`TARGET_INSTANCE_ID` = `X-Instance-Id` (`api1`/`api2`); hook делает `docker compose stop` только этой реплики и оставляет её остановленной. После теста: `docker compose --env-file .env start api1` (или `api2`). Для защиты повторить на второй реплике после восстановления первой. + +**Остановка:** + +```sh +docker compose --env-file .env down +``` + +Намеренное удаление учебных данных (volumes): + +```sh +docker compose --env-file .env down -v +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +HTTP-клиент + → lb (Nginx) + → api1 / api2 (uvicorn + FastAPI) + → PostgreSQL + users, chats, chat_members, messages, message_attachments, + attachments (метаданные), sessions, idempotency_records + → MinIO (S3, образ alpine/minio:RELEASE.2025-10-15T17-29-55Z) + байты оригиналов в bucket messenger-attachments +``` + +- Источник истины для метаданных — PostgreSQL; байты оригиналов — только в S3, не в БД и не на локальном диске API. +- Object key назначает сервер (`attachments/{chat_id}/{attachment_id}`); `filename` только для отображения. +- `POST .../attachments` читает тело с лимитом до `MAX_UPLOAD_BYTES+` отказа, проверяет MIME по содержимому (PNG/JPEG), лимит пикселей через Pillow, затем `PutObject` и запись метаданных; ответ `201` со `status=ready`. +- Download только через авторизованный API без redirect; посторонний участник получает `404`. +- Сессии в PostgreSQL: один Bearer работает через любую реплику без sticky sessions. +- `X-Instance-Id` стабилен на жизнь процесса (`INSTANCE_ID` сервиса). +- `Idempotency-Key` обязателен на `POST .../messages`; хеш тела учитывает `text` и `attachment_ids`. +- ORM-модели: `src/messenger/tables.py`. Доступ к данным: `src/messenger/store.py`. S3: `src/messenger/s3util.py`. +- Миграции: SQL в `migrations/` (+ `003_attachments.sql`) + one-shot `migrate`; Alembic не используется. +- Порты API и MinIO наружу не публикуются; публичная точка входа — LB (`infra/nginx.conf`: `client_max_body_size 11m`, `least_conn`). +- Compose: `lb` + `api1` + `api2` + `postgres` + `s3` + `migrate`, volumes `pgdata` и `miniodata`; сервис `s3` с `user: "0:0"`, чтобы alpine/MinIO мог писать в named volume; `.env` в Git не коммитится. + +Перенесено из lab3: auth Basic→Bearer, Argon2id, чаты/сообщения, LB, две реплики, идемпотентность, restart/stop-one. +Добавлено в lab4: MinIO, Attachment/message_attachments, upload/download, `attachment_ids` в сообщениях, готовность с проверкой S3. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke (lab3 + вложения/SHA-256/чужой 404) | `python tests/smoke.py --base-url http://127.0.0.1:8083` | `PASS: lab4 public API scenario...` | `evidence/smoke.txt` | +| Стенд: ≥2 API, LB, Postgres, MinIO | `docker compose --env-file .env ps` | `lb`, `api1`, `api2`, `postgres`, `s3` (`alpine/minio:RELEASE.2025-10-15T17-29-55Z`); migrate Exited 0 | `evidence/compose-ps.txt` | +| Persistence: рестарт без удаления volumes, прежний токен и тот же файл | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8083` | `PASS: persistence preserved...` | `evidence/restart.txt` | +| Failover: остановка одной API-реплики; файл через другую | `python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://127.0.0.1:8083` | failover PASS; `first_recovery_seconds≈2.64`; attachment bytes совпали | `evidence/failover.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Для оценки 3 отдельный нагрузочный трек не выполнялся. Проверены сохранность (БД+S3) и отказ API-реплики с повторным чтением вложения: | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker compose --env-file .env restart` (postgres+s3+api1+api2+lb), volumes сохранены | `/health/ready` ok; прежний Bearer; тот же оригинал по `/content` | persistence PASS | в бюджете теста; потери данных нет | +| `docker compose stop` одной API-реплики | LB обслуживает живую; download оригинала через другую реплику | failover PASS; `first_recovery_seconds≈2.64` | подтверждённые сообщения и файл на месте | + +Локальная проверка автора выполнялась на `HOST_PORT=8083`. На Windows для публичных тестов задайте `PYTHONUTF8=1` (иначе чтение `contracts/openapi.json` может упасть на cp1251). + +Аппаратный профиль: локальный Docker Desktop на Windows; 2 API + Nginx + PostgreSQL + MinIO без CPU/RAM limits. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- отдельные S3 credentials с минимальными правами, reconciler orphan-объектов, эксперимент ≥10 загрузок, presigned upload не выполнялись. +- Единственный PostgreSQL, единственный MinIO и единственный Nginx — SPOF; отказ host/узла не выдерживается. +- При сбое между PutObject и COMMIT возможны неучтённые объекты в bucket. +- Basic по HTTP допустим только на локальном учебном стенде с синтетическими данными. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..bf4fdd07 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,153 @@ +x-api: &api + build: . + image: mtusi-messenger:lab4 + expose: + - "8080" + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: lab + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + SESSION_STORE: postgres + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000} + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-minioadmin} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-minioadmin} + MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760} + MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000} + depends_on: + migrate: + condition: service_completed_successfully + postgres: + condition: service_healthy + s3: + condition: service_healthy + healthcheck: + test: + [ + "CMD", + "python", + "-c", + "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)", + ] + interval: 3s + timeout: 3s + retries: 30 + start_period: 10s + restart: unless-stopped + +services: + postgres: + image: postgres:16-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD: messenger + POSTGRES_DB: messenger + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 3s + timeout: 3s + retries: 20 + restart: unless-stopped + + s3: + # Official minio/minio left Docker Hub; community Alpine image of MinIO. + image: alpine/minio:RELEASE.2025-10-15T17-29-55Z + user: "0:0" + command: ["server", "/data", "--address", ":9000", "--console-address", ":9001"] + environment: + MINIO_ROOT_USER: ${S3_ACCESS_KEY_ID:-minioadmin} + MINIO_ROOT_PASSWORD: ${S3_SECRET_ACCESS_KEY:-minioadmin} + volumes: + - miniodata:/data + healthcheck: + test: + [ + "CMD", + "wget", + "-qO-", + "http://127.0.0.1:9000/minio/health/live", + ] + interval: 3s + timeout: 3s + retries: 30 + start_period: 10s + restart: unless-stopped + + migrate: + build: . + image: mtusi-messenger:lab4 + environment: + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + command: ["python", "/app/scripts/migrate.py"] + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api1: + <<: *api + hostname: api1 + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: lab + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + SESSION_STORE: postgres + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000} + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-minioadmin} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-minioadmin} + MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760} + MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000} + INSTANCE_ID: api1 + + api2: + <<: *api + hostname: api2 + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: lab + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + SESSION_STORE: postgres + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000} + S3_REGION: ${S3_REGION:-us-east-1} + S3_BUCKET: ${S3_BUCKET:-messenger-attachments} + S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:-minioadmin} + S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:-minioadmin} + MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760} + MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000} + INSTANCE_ID: api2 + + lb: + image: nginx:1.27-alpine + ports: + - "127.0.0.1:${HOST_PORT:-8080}:80" + volumes: + - ./infra/nginx.conf:/etc/nginx/nginx.conf:ro + depends_on: + api1: + condition: service_healthy + api2: + condition: service_healthy + healthcheck: + test: ["CMD", "wget", "-qO-", "http://127.0.0.1/health/live"] + interval: 3s + timeout: 3s + retries: 20 + restart: unless-stopped + +volumes: + pgdata: + miniodata: diff --git a/evidence/compose-ps.txt b/evidence/compose-ps.txt new file mode 100644 index 0000000000000000000000000000000000000000..5147f404e66a35e32fd0f6973916063941b6ce21 GIT binary patch literal 2014 zcmdUwPfr3d6vXFj;&<5W!9Ryp7evK_i9usb6b+~cZ-|IQTn#Hmzr6Z;U1S%;WI;Wc zrlquf(|OZr_x-J^T^(y*-i+mt=v^KB0AcdZ6`g==*j4T2;#P-4O&2;;CBvq|*ghy{ zw3Bh_%-Q_8>bdqYzNfIO5mVQ^=5((o^%bk5g4U=T>Z+kDtt-%t9@Ntvy@noH5z-6C z_DSOduv#F+w2|7hJ#7!sCM)&*s1MF9dj)FJE`s(#wSHgEaA`Vjkrq6E!040XC}xqY zJeYOh)F)SC=#fvG_+;fdxq0O6Ip&5N>DsMYffSyPz^7CCcT%bAARZxsg5IPIIp3oZR4C8}w7Z8pkZNq;JT1 T-q7i8ewkdX1fbh*IHKtX66OV# literal 0 HcmV?d00001 diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 0000000000000000000000000000000000000000..264485d226d852c38c3a82040993e34ac701bf6c GIT binary patch literal 596 zcmYk3%}T^T5QOV2_zpwPvf%o2(9<3SkHS7ch)L97b`$cqE8?rGU-xXnG9=T}Q&nBv z^Y{Ctqe|r(HK@{F?+TocYE^U2`35p?%7|(;nz-%Ad=NMK)Zl-q6)&OgzOI_$&3HVo6>D)!3)EPaB8P0RBl7cDm+c-bb z1GUz=;-A1BK}B2-W~8H32awjKd5riw-JTe8-{w4}%HX&iJ(;tJzFDvpO6Df@+BqKL zw7$s1o*H}>3v*3x_td)9kN5bZjkYZFJXfAI!ZJsjzv6-3@Lct!VA7APpV47@o literal 0 HcmV?d00001 diff --git a/evidence/restart.txt b/evidence/restart.txt new file mode 100644 index 0000000000000000000000000000000000000000..c25cebacdd766ee09d14e1573471e896f0a4fc5d GIT binary patch literal 380 zcmZ{gK@Ng25Jmsm#5?o^96(ntOkA3H0#Z_AMdi>HGz5_j-R;(@cEI#A`5 zYvQgVQuC6dwYsoMA6WrbroDE$>ZBX%0QaA#wUarXmTsOdjqYgodM{W(x4|&$ srwO+n%ySj_8MPN8o7mfPFNq+Tl(35PAC-I>EF^UKdQS&(EtDd literal 0 HcmV?d00001 diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000000000000000000000000000000000000..450bb652abf7197246e62291be82549ab7018a0b GIT binary patch literal 174 zcmW-bF%H5o5Co@2;tzfS6%|w|(?#M12Ae2S5>QBZK4ffJ^6lP@_U`}dXt?<<1V$ov z&Z;+?YGmM{Yv^dLA6;gaTAaMN+8gvweRR57H<{IckqmZclC`fys&uc None: + init_engine() + try: + apply_migrations() + print("migrations applied") + finally: + close_engine() + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..45a5881a --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,4 @@ +@echo off +cd /d "%~dp0\.." +docker compose --env-file .env restart postgres s3 api1 api2 lb +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..497729fa --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart postgres s3 api1 api2 lb diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..9dec733b --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,12 @@ +@echo off +cd /d "%~dp0\.." +if "%TARGET_INSTANCE_ID%"=="" ( + echo TARGET_INSTANCE_ID is required >&2 + exit /b 1 +) +if /I not "%TARGET_INSTANCE_ID%"=="api1" if /I not "%TARGET_INSTANCE_ID%"=="api2" ( + echo unknown TARGET_INSTANCE_ID: %TARGET_INSTANCE_ID% >&2 + exit /b 1 +) +docker compose --env-file .env stop %TARGET_INSTANCE_ID% +exit /b %ERRORLEVEL% diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..20c5cafc --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,14 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" + +case "$TARGET_INSTANCE_ID" in + api1|api2) + docker compose --env-file .env stop "$TARGET_INSTANCE_ID" + ;; + *) + printf '%s\n' "unknown TARGET_INSTANCE_ID: $TARGET_INSTANCE_ID" >&2 + exit 1 + ;; +esac diff --git a/src/messenger/__init__.py b/src/messenger/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/messenger/app.py b/src/messenger/app.py new file mode 100644 index 00000000..65a0cf22 --- /dev/null +++ b/src/messenger/app.py @@ -0,0 +1,323 @@ +from __future__ import annotations + +import base64 +import binascii +import os +import re +import socket +import uuid +from contextlib import asynccontextmanager +from typing import Optional +from uuid import UUID + +from fastapi import Depends, FastAPI, Header, Query, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse, Response +from starlette.exceptions import HTTPException as StarletteHTTPException + +from .cursors import decode_cursor, encode_cursor +from .db import close_engine, init_engine, ping +from .errors import AppError, error_response, request_id_of +from .images import ( + max_upload_bytes, + sniff_image, + validate_filename, + validate_image_pixels, +) +from .models import CreateChat, CreateMessage, CreateUser +from .s3util import close_s3, ensure_bucket, ping_s3 +from .store import store + +BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} +BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'} +IDEMPOTENCY_KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") +INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname() + + +@asynccontextmanager +async def lifespan(_app: FastAPI): + init_engine() + ensure_bucket() + yield + close_s3() + close_engine() + + +app = FastAPI(title="MTUSI Messenger lab4", version="1.4.0", lifespan=lifespan) + + +@app.middleware("http") +async def attach_request_and_instance(request: Request, call_next): + incoming = request.headers.get("x-request-id") + request.state.request_id = incoming.strip() if incoming and incoming.strip() else str(uuid.uuid4()) + response = await call_next(request) + response.headers["X-Request-Id"] = request.state.request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +@app.exception_handler(AppError) +async def app_error_handler(request: Request, exc: AppError) -> JSONResponse: + return error_response( + exc.status_code, + exc.code, + exc.message, + request_id_of(request), + headers=exc.headers, + ) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse: + return error_response( + 400, + "invalid_request", + "Request validation failed", + request_id_of(request), + ) + + +@app.exception_handler(StarletteHTTPException) +async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse: + code = "not_found" if exc.status_code == 404 else "invalid_request" + headers = None + if exc.status_code == 401: + code = "unauthorized" + headers = BEARER_CHALLENGE + elif exc.status_code >= 500: + code = "internal_error" + message = exc.detail if isinstance(exc.detail, str) else "Request failed" + return error_response( + exc.status_code, + code, + message, + request_id_of(request), + headers=headers, + ) + + +@app.exception_handler(Exception) +async def unhandled_error_handler(request: Request, exc: Exception) -> JSONResponse: + return error_response(500, "internal_error", "Internal server error", request_id_of(request)) + + +def current_user_id(authorization: Optional[str] = Header(default=None)) -> str: + if authorization is None or not authorization.strip(): + raise AppError(401, "unauthorized", "Missing bearer token", headers=BEARER_CHALLENGE) + scheme, _, credential = authorization.partition(" ") + if scheme.lower() != "bearer" or not credential.strip(): + raise AppError(401, "unauthorized", "Bearer token required", headers=BEARER_CHALLENGE) + return store.resolve_bearer(credential.strip()) + + +def require_chat_member(chat_id: UUID, user_id: str): + chat = store.get_chat(str(chat_id)) + if chat is None or user_id not in chat.member_ids: + raise AppError(404, "not_found", "Chat not found") + return chat + + +def parse_basic_credentials(authorization: Optional[str]) -> tuple[str, str]: + if authorization is None or not authorization.strip(): + raise AppError(401, "unauthorized", "Missing basic credentials", headers=BASIC_CHALLENGE) + scheme, _, credential = authorization.partition(" ") + if scheme.lower() != "basic" or not credential.strip(): + raise AppError(401, "unauthorized", "Basic credentials required", headers=BASIC_CHALLENGE) + try: + decoded = base64.b64decode(credential.strip(), validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError, ValueError) as exc: + raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE) from exc + if ":" not in decoded: + raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE) + username, password = decoded.split(":", 1) + if not username or not username.isascii(): + raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE) + return username, password + + +def require_idempotency_key(idempotency_key: Optional[str] = Header(default=None, alias="Idempotency-Key")) -> str: + if idempotency_key is None or not idempotency_key.strip(): + raise AppError(400, "invalid_request", "Idempotency-Key is required") + key = idempotency_key.strip() + if not IDEMPOTENCY_KEY_RE.fullmatch(key): + raise AppError(400, "invalid_request", "Idempotency-Key format is invalid") + return key + + +async def read_upload_body(request: Request) -> bytes: + limit = max_upload_bytes() + content_length = request.headers.get("content-length") + if content_length is not None: + try: + declared = int(content_length) + except ValueError as exc: + raise AppError(400, "invalid_request", "Invalid Content-Length") from exc + if declared > limit: + raise AppError(413, "payload_too_large", "Upload exceeds size limit") + chunks: list[bytes] = [] + total = 0 + async for chunk in request.stream(): + if not chunk: + continue + total += len(chunk) + if total > limit: + raise AppError(413, "payload_too_large", "Upload exceeds size limit") + chunks.append(chunk) + data = b"".join(chunks) + if not data: + raise AppError(400, "invalid_request", "Empty upload body") + return data + + +@app.get("/health/live") +def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def health_ready(): + if not ping(): + raise AppError(503, "unavailable", "Database is unavailable") + if not ping_s3(): + raise AppError(503, "unavailable", "Object storage is unavailable") + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def register_user(body: CreateUser): + user = store.create_user(body.username, body.display_name, body.password) + return user.to_dict() + + +@app.post("/api/v1/auth/sessions", status_code=201) +def create_session(authorization: Optional[str] = Header(default=None)): + username, password = parse_basic_credentials(authorization) + session = store.create_session(username, password) + return session.to_dict() + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def revoke_session(authorization: Optional[str] = Header(default=None)): + if authorization is None or not authorization.strip(): + raise AppError(401, "unauthorized", "Missing bearer token", headers=BEARER_CHALLENGE) + scheme, _, credential = authorization.partition(" ") + if scheme.lower() != "bearer" or not credential.strip(): + raise AppError(401, "unauthorized", "Bearer token required", headers=BEARER_CHALLENGE) + store.revoke_session(credential.strip()) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +def get_me(user_id: str = Depends(current_user_id)): + user = store.get_user(user_id) + if user is None: + raise AppError(401, "unauthorized", "Unknown user", headers=BEARER_CHALLENGE) + return user.to_dict() + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(body: CreateChat, user_id: str = Depends(current_user_id)): + member_ids = [str(m) for m in body.member_ids] + if user_id not in member_ids: + raise AppError(400, "invalid_request", "Caller must be included in member_ids") + chat = store.create_chat(body.title, member_ids) + return chat.to_dict() + + +@app.get("/api/v1/chats") +def list_chats( + user_id: str = Depends(current_user_id), + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +): + resource = f"chats:{user_id}" + after = decode_cursor(cursor, resource) if cursor else None + page, last_for_cursor = store.list_chats_for_user(user_id, limit, after) + next_cursor = None + if last_for_cursor is not None: + next_cursor = encode_cursor(last_for_cursor.created_at, last_for_cursor.id, resource) + return {"items": [c.to_dict() for c in page], "next_cursor": next_cursor} + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: UUID, user_id: str = Depends(current_user_id)): + chat = require_chat_member(chat_id, user_id) + return chat.to_dict() + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def create_message( + chat_id: UUID, + body: CreateMessage, + request: Request, + user_id: str = Depends(current_user_id), + idempotency_key: str = Depends(require_idempotency_key), +): + require_chat_member(chat_id, user_id) + message = store.create_message( + str(chat_id), + user_id, + body.text, + [str(item) for item in body.attachment_ids], + idempotency_key=idempotency_key, + request_path=request.url.path, + ) + return message.to_dict() + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages( + chat_id: UUID, + user_id: str = Depends(current_user_id), + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +): + require_chat_member(chat_id, user_id) + resource = f"messages:{chat_id}" + after = decode_cursor(cursor, resource) if cursor else None + page, last_for_cursor = store.list_messages(str(chat_id), limit, after) + next_cursor = None + if last_for_cursor is not None: + next_cursor = encode_cursor(last_for_cursor.created_at, last_for_cursor.id, resource) + return {"items": [m.to_dict() for m in page], "next_cursor": next_cursor} + + +@app.post("/api/v1/chats/{chat_id}/attachments", status_code=201) +async def upload_attachment( + chat_id: UUID, + request: Request, + filename: str = Query(...), + user_id: str = Depends(current_user_id), +): + require_chat_member(chat_id, user_id) + safe_name = validate_filename(filename) + content_type = (request.headers.get("content-type") or "").split(";")[0].strip().lower() + data = await read_upload_body(request) + detected = sniff_image(data, content_type) + validate_image_pixels(data, detected) + attachment = store.create_attachment( + str(chat_id), + user_id, + safe_name, + detected, + data, + ) + return attachment.to_dict() + + +@app.get("/api/v1/attachments/{attachment_id}") +def get_attachment(attachment_id: UUID, user_id: str = Depends(current_user_id)): + attachment = store.get_attachment_for_user(str(attachment_id), user_id) + return attachment.to_dict() + + +@app.get("/api/v1/attachments/{attachment_id}/content") +def download_attachment( + attachment_id: UUID, + user_id: str = Depends(current_user_id), + variant: str = Query(default="original"), +): + data, content_type = store.download_attachment_for_user( + str(attachment_id), user_id, variant=variant + ) + return Response(content=data, media_type=content_type) diff --git a/src/messenger/cursors.py b/src/messenger/cursors.py new file mode 100644 index 00000000..67fdd0b4 --- /dev/null +++ b/src/messenger/cursors.py @@ -0,0 +1,34 @@ +from __future__ import annotations + +import base64 +import json +from typing import Tuple + +from .errors import AppError + + +def encode_cursor(created_at: str, item_id: str, resource: str) -> str: + raw = json.dumps( + {"t": created_at, "i": item_id, "r": resource}, + separators=(",", ":"), + ensure_ascii=False, + ).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def decode_cursor(cursor: str, expected_resource: str) -> Tuple[str, str]: + try: + padded = cursor + "=" * (-len(cursor) % 4) + data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")).decode("utf-8")) + created_at = data["t"] + item_id = data["i"] + resource = data["r"] + if not isinstance(created_at, str) or not isinstance(item_id, str): + raise ValueError("bad cursor fields") + if resource != expected_resource: + raise AppError(400, "invalid_request", "Cursor does not belong to this resource") + return created_at, item_id + except AppError: + raise + except Exception as exc: + raise AppError(400, "invalid_request", "Invalid cursor") from exc diff --git a/src/messenger/db.py b/src/messenger/db.py new file mode 100644 index 00000000..feff3d18 --- /dev/null +++ b/src/messenger/db.py @@ -0,0 +1,115 @@ +from __future__ import annotations + +import os +from contextlib import contextmanager +from pathlib import Path +from typing import Iterator, Optional + +from sqlalchemy import create_engine, text +from sqlalchemy.engine import Engine +from sqlalchemy.orm import Session, sessionmaker + +_engine: Optional[Engine] = None +_SessionLocal: Optional[sessionmaker[Session]] = None + + +def _read_database_url() -> str: + url_file = os.environ.get("DATABASE_URL_FILE") + if url_file: + url = Path(url_file).read_text(encoding="utf-8").strip() + else: + url = os.environ.get("DATABASE_URL") + if not url: + raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required") + url = url.strip() + if url.startswith("postgresql://"): + url = "postgresql+psycopg://" + url[len("postgresql://") :] + elif url.startswith("postgres://"): + url = "postgresql+psycopg://" + url[len("postgres://") :] + return url + + +def init_engine() -> Engine: + global _engine, _SessionLocal + if _engine is not None: + return _engine + _engine = create_engine( + _read_database_url(), + pool_size=5, + max_overflow=5, + pool_pre_ping=True, + pool_timeout=10, + ) + _SessionLocal = sessionmaker(bind=_engine, expire_on_commit=False) + return _engine + + +def get_engine() -> Engine: + if _engine is None: + raise RuntimeError("database engine is not initialized") + return _engine + + +@contextmanager +def session_scope() -> Iterator[Session]: + if _SessionLocal is None: + raise RuntimeError("database engine is not initialized") + session = _SessionLocal() + try: + yield session + session.commit() + except Exception: + session.rollback() + raise + finally: + session.close() + + +def close_engine() -> None: + global _engine, _SessionLocal + if _engine is not None: + _engine.dispose() + _engine = None + _SessionLocal = None + + +def migrations_dir() -> Path: + return Path(__file__).resolve().parents[2] / "migrations" + + +def apply_migrations() -> None: + engine = get_engine() + with engine.begin() as conn: + conn.execute( + text( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + ) + """ + ) + ) + applied = { + row[0] + for row in conn.execute(text("SELECT version FROM schema_migrations")).fetchall() + } + for path in sorted(migrations_dir().glob("*.sql")): + version = path.name + if version in applied: + continue + conn.exec_driver_sql(path.read_text(encoding="utf-8")) + conn.execute( + text("INSERT INTO schema_migrations (version) VALUES (:version)"), + {"version": version}, + ) + + +def ping() -> bool: + try: + engine = get_engine() + with engine.connect() as conn: + conn.execute(text("SELECT 1")) + return True + except Exception: + return False diff --git a/src/messenger/errors.py b/src/messenger/errors.py new file mode 100644 index 00000000..8adfcc2d --- /dev/null +++ b/src/messenger/errors.py @@ -0,0 +1,45 @@ +from __future__ import annotations + +from typing import Optional + +from fastapi import Request +from fastapi.responses import JSONResponse + + +class AppError(Exception): + def __init__( + self, + status_code: int, + code: str, + message: str, + headers: Optional[dict] = None, + ) -> None: + self.status_code = status_code + self.code = code + self.message = message + self.headers = headers + super().__init__(message) + + +def request_id_of(request: Request) -> str: + return getattr(request.state, "request_id", "unknown") + + +def error_response( + status_code: int, + code: str, + message: str, + request_id: str, + headers: Optional[dict] = None, +) -> JSONResponse: + payload = { + "error": { + "code": code, + "message": message, + "request_id": request_id, + } + } + response_headers = {"X-Request-Id": request_id} + if headers: + response_headers.update(headers) + return JSONResponse(status_code=status_code, content=payload, headers=response_headers) diff --git a/src/messenger/images.py b/src/messenger/images.py new file mode 100644 index 00000000..df799555 --- /dev/null +++ b/src/messenger/images.py @@ -0,0 +1,68 @@ +from __future__ import annotations + +import io +import os +from typing import Tuple + +from PIL import Image, UnidentifiedImageError + +from .errors import AppError + +PNG_MAGIC = b"\x89PNG\r\n\x1a\n" +JPEG_MAGIC = b"\xff\xd8\xff" + + +def max_upload_bytes() -> int: + return max(1, int(os.environ.get("MAX_UPLOAD_BYTES", "10485760"))) + + +def max_image_pixels() -> int: + return max(1, int(os.environ.get("MAX_IMAGE_PIXELS", "40000000"))) + + +def validate_filename(filename: str) -> str: + if len(filename) < 1 or len(filename) > 255: + raise AppError(400, "invalid_request", "filename length is invalid") + for ch in filename: + code = ord(ch) + if ch in "/\\" or code == 0 or code < 32: + raise AppError(400, "invalid_request", "filename contains forbidden characters") + return filename + + +def sniff_image(data: bytes, declared_content_type: str) -> str: + if declared_content_type not in {"image/png", "image/jpeg"}: + raise AppError(415, "unsupported_media_type", "Unsupported media type") + if data.startswith(PNG_MAGIC): + detected = "image/png" + elif data.startswith(JPEG_MAGIC): + detected = "image/jpeg" + else: + raise AppError(415, "unsupported_media_type", "Unsupported or corrupted image") + if detected != declared_content_type: + raise AppError(415, "unsupported_media_type", "Content-Type does not match body") + return detected + + +def validate_image_pixels(data: bytes, content_type: str) -> Tuple[int, int]: + Image.MAX_IMAGE_PIXELS = max_image_pixels() + try: + with Image.open(io.BytesIO(data)) as img: + fmt = (img.format or "").upper() + if content_type == "image/png" and fmt != "PNG": + raise AppError(415, "unsupported_media_type", "Invalid PNG image") + if content_type == "image/jpeg" and fmt not in {"JPEG", "MPO"}: + raise AppError(415, "unsupported_media_type", "Invalid JPEG image") + width, height = img.size + if width < 1 or height < 1: + raise AppError(415, "unsupported_media_type", "Invalid image dimensions") + if width * height > max_image_pixels(): + raise AppError(413, "payload_too_large", "Image exceeds pixel limit") + img.load() + return width, height + except AppError: + raise + except Image.DecompressionBombError as exc: + raise AppError(413, "payload_too_large", "Image exceeds pixel limit") from exc + except (UnidentifiedImageError, OSError, ValueError, SyntaxError) as exc: + raise AppError(415, "unsupported_media_type", "Unsupported or corrupted image") from exc diff --git a/src/messenger/models.py b/src/messenger/models.py new file mode 100644 index 00000000..6b1fdf6e --- /dev/null +++ b/src/messenger/models.py @@ -0,0 +1,81 @@ +from __future__ import annotations + +import re +from typing import List +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + + +def _not_blank(value: str, field_name: str) -> str: + if value.strip() == "": + raise ValueError(f"{field_name} must not be blank") + return value + + +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + + username: str + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def validate_username(cls, value: str) -> str: + if not USERNAME_RE.fullmatch(value): + raise ValueError("username must match [a-z0-9_]{3,32}") + return value + + @field_validator("display_name") + @classmethod + def validate_display_name(cls, value: str) -> str: + return _not_blank(value, "display_name") + + @field_validator("password") + @classmethod + def validate_password(cls, value: str) -> str: + if len(value) < 12 or len(value) > 128: + raise ValueError("password length must be 12-128") + return value + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field(min_length=1, max_length=100) + member_ids: List[UUID] = Field(min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def validate_title(cls, value: str) -> str: + return _not_blank(value, "title") + + @field_validator("member_ids") + @classmethod + def validate_members(cls, value: List[UUID]) -> List[UUID]: + if len(value) != len(set(value)): + raise ValueError("member_ids must be unique") + return value + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + + text: str = Field(max_length=4000) + attachment_ids: List[UUID] = Field(default_factory=list, max_length=10) + + @field_validator("attachment_ids") + @classmethod + def validate_attachment_ids(cls, value: List[UUID]) -> List[UUID]: + if len(value) != len(set(value)): + raise ValueError("attachment_ids must be unique") + return value + + @model_validator(mode="after") + def validate_text_or_attachments(self) -> "CreateMessage": + if self.text.strip() == "" and not self.attachment_ids: + raise ValueError("text must not be blank without attachments") + return self diff --git a/src/messenger/s3util.py b/src/messenger/s3util.py new file mode 100644 index 00000000..da7a6f7d --- /dev/null +++ b/src/messenger/s3util.py @@ -0,0 +1,113 @@ +from __future__ import annotations + +import os +from pathlib import Path +from typing import Optional + +import boto3 +from botocore.client import BaseClient, Config +from botocore.exceptions import ClientError + +from .errors import AppError + +_client: Optional[BaseClient] = None + + +def _read_secret(env_name: str, file_env_name: str) -> str: + path = os.environ.get(file_env_name) + if path: + return Path(path).read_text(encoding="utf-8").strip() + value = os.environ.get(env_name) + if not value: + raise RuntimeError(f"{env_name} or {file_env_name} is required") + return value.strip() + + +def s3_endpoint() -> str: + return os.environ.get("S3_ENDPOINT", "http://s3:9000").rstrip("/") + + +def s3_bucket() -> str: + return os.environ.get("S3_BUCKET", "messenger-attachments") + + +def s3_region() -> str: + return os.environ.get("S3_REGION", "us-east-1") + + +def get_s3_client() -> BaseClient: + global _client + if _client is None: + _client = boto3.client( + "s3", + endpoint_url=s3_endpoint(), + region_name=s3_region(), + aws_access_key_id=_read_secret("S3_ACCESS_KEY_ID", "S3_ACCESS_KEY_ID_FILE"), + aws_secret_access_key=_read_secret( + "S3_SECRET_ACCESS_KEY", "S3_SECRET_ACCESS_KEY_FILE" + ), + config=Config(s3={"addressing_style": "path"}), + ) + return _client + + +def ensure_bucket() -> None: + client = get_s3_client() + bucket = s3_bucket() + try: + client.head_bucket(Bucket=bucket) + except ClientError: + try: + client.create_bucket(Bucket=bucket) + except ClientError as exc: + code = exc.response.get("Error", {}).get("Code", "") + if code not in {"BucketAlreadyOwnedByYou", "BucketAlreadyExists"}: + raise + try: + client.put_public_access_block( + Bucket=bucket, + PublicAccessBlockConfiguration={ + "BlockPublicAcls": True, + "IgnorePublicAcls": True, + "BlockPublicPolicy": True, + "RestrictPublicBuckets": True, + }, + ) + except ClientError: + pass + + +def put_object(object_key: str, data: bytes, content_type: str) -> None: + try: + get_s3_client().put_object( + Bucket=s3_bucket(), + Key=object_key, + Body=data, + ContentType=content_type, + ) + except ClientError as exc: + raise AppError(503, "unavailable", "Object storage is unavailable") from exc + + +def get_object_bytes(object_key: str) -> bytes: + try: + response = get_s3_client().get_object(Bucket=s3_bucket(), Key=object_key) + return response["Body"].read() + except ClientError as exc: + code = exc.response.get("Error", {}).get("Code", "") + if code in {"NoSuchKey", "404", "NotFound"}: + raise AppError(404, "not_found", "Attachment not found") from exc + raise AppError(503, "unavailable", "Object storage is unavailable") from exc + + +def ping_s3() -> bool: + try: + get_s3_client().head_bucket(Bucket=s3_bucket()) + return True + except Exception: + return False + + +def close_s3() -> None: + global _client + _client = None diff --git a/src/messenger/store.py b/src/messenger/store.py new file mode 100644 index 00000000..23ea12ca --- /dev/null +++ b/src/messenger/store.py @@ -0,0 +1,559 @@ +from __future__ import annotations + +import hashlib +import json +import os +import secrets +import uuid +from dataclasses import dataclass, field +from datetime import datetime, timedelta, timezone +from typing import List, Optional, Tuple +from uuid import UUID + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError +from sqlalchemy import delete, func, select, tuple_ +from sqlalchemy.exc import IntegrityError + +from .db import session_scope +from .errors import AppError +from .s3util import get_object_bytes, put_object +from .tables import ( + AttachmentRow, + ChatMemberRow, + ChatRow, + IdempotencyRow, + MessageAttachmentRow, + MessageRow, + SessionRow, + UserRow, +) + +password_hasher = PasswordHasher() + + +def utc_now() -> datetime: + return datetime.now(timezone.utc) + + +def format_ts(value: datetime) -> str: + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def parse_ts(value: str) -> datetime: + return datetime.fromisoformat(value.replace("Z", "+00:00")) + + +def session_ttl_seconds() -> int: + raw = os.environ.get("SESSION_TTL_SECONDS", "3600") + return max(1, int(raw)) + + +def idempotency_ttl_seconds() -> int: + raw = os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400") + return max(1, int(raw)) + + +def hash_token(token: str) -> str: + return hashlib.sha256(token.encode("utf-8")).hexdigest() + + +def request_body_hash(text: str, attachment_ids: List[str]) -> str: + normalized = json.dumps( + {"text": text, "attachment_ids": attachment_ids}, + separators=(",", ":"), + ensure_ascii=False, + ) + return hashlib.sha256(normalized.encode("utf-8")).hexdigest() + + +def idempotency_scope(user_id: str, method: str, path: str, key: str) -> str: + return f"{user_id}|{method.upper()}|{path}|{key}" + + +@dataclass +class User: + id: str + username: str + display_name: str + created_at: str + + def to_dict(self) -> dict: + return { + "id": self.id, + "username": self.username, + "display_name": self.display_name, + "created_at": self.created_at, + } + + +@dataclass +class Chat: + id: str + title: str + member_ids: List[str] + created_at: str + + def to_dict(self) -> dict: + return { + "id": self.id, + "title": self.title, + "member_ids": list(self.member_ids), + "created_at": self.created_at, + } + + +@dataclass +class Message: + id: str + chat_id: str + sender_id: str + text: str + created_at: str + attachment_ids: List[str] = field(default_factory=list) + + def to_dict(self) -> dict: + return { + "id": self.id, + "chat_id": self.chat_id, + "sender_id": self.sender_id, + "text": self.text, + "created_at": self.created_at, + "attachment_ids": list(self.attachment_ids), + } + + +@dataclass +class Attachment: + id: str + chat_id: str + owner_id: str + filename: str + content_type: str + size_bytes: int + sha256: str + status: str + variants: List[dict] + error_code: Optional[str] + created_at: str + updated_at: str + object_key: str = "" + + def to_dict(self) -> dict: + return { + "id": self.id, + "chat_id": self.chat_id, + "owner_id": self.owner_id, + "filename": self.filename, + "content_type": self.content_type, + "size_bytes": self.size_bytes, + "sha256": self.sha256, + "status": self.status, + "variants": list(self.variants), + "error_code": self.error_code, + "created_at": self.created_at, + "updated_at": self.updated_at, + } + + +@dataclass +class Session: + token: str + token_type: str + expires_at: str + user: User + + def to_dict(self) -> dict: + return { + "token": self.token, + "token_type": self.token_type, + "expires_at": self.expires_at, + "user": self.user.to_dict(), + } + + +def _user_from_row(row: UserRow) -> User: + return User( + id=str(row.id), + username=row.username, + display_name=row.display_name, + created_at=format_ts(row.created_at), + ) + + +def _chat_from_row(row: ChatRow, member_ids: List[str]) -> Chat: + return Chat( + id=str(row.id), + title=row.title, + member_ids=member_ids, + created_at=format_ts(row.created_at), + ) + + +def _attachment_from_row(row: AttachmentRow) -> Attachment: + return Attachment( + 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=int(row.size_bytes), + sha256=row.sha256, + status=row.status, + variants=[], + error_code=row.error_code, + created_at=format_ts(row.created_at), + updated_at=format_ts(row.updated_at), + object_key=row.object_key, + ) + + +def _message_attachment_ids(session, message_id: UUID) -> List[str]: + rows = session.scalars( + select(MessageAttachmentRow.attachment_id) + .where(MessageAttachmentRow.message_id == message_id) + .order_by(MessageAttachmentRow.position.asc()) + ).all() + return [str(attachment_id) for attachment_id in rows] + + +def _message_from_row(session, row: MessageRow) -> Message: + return Message( + id=str(row.id), + chat_id=str(row.chat_id), + sender_id=str(row.sender_id), + text=row.text, + created_at=format_ts(row.created_at), + attachment_ids=_message_attachment_ids(session, row.id), + ) + + +def _member_ids(session, chat_id: UUID) -> List[str]: + rows = session.scalars( + select(ChatMemberRow.user_id) + .where(ChatMemberRow.chat_id == chat_id) + .order_by(ChatMemberRow.user_id) + ).all() + return [str(user_id) for user_id in rows] + + +def _aware(value: datetime) -> datetime: + if value.tzinfo is None: + return value.replace(tzinfo=timezone.utc) + return value + + +def _is_chat_member(session, chat_id: UUID, user_id: str) -> bool: + row = session.get(ChatMemberRow, {"chat_id": chat_id, "user_id": UUID(user_id)}) + return row is not None + + +class Store: + def create_user(self, username: str, display_name: str, password: str) -> User: + row = UserRow( + id=uuid.uuid4(), + username=username, + display_name=display_name, + password_hash=password_hasher.hash(password), + created_at=utc_now(), + ) + try: + with session_scope() as session: + session.add(row) + session.flush() + return _user_from_row(row) + except IntegrityError as exc: + raise AppError(409, "conflict", "Username is already taken") from exc + + def get_user(self, user_id: str) -> Optional[User]: + with session_scope() as session: + row = session.get(UserRow, UUID(user_id)) + return _user_from_row(row) if row else None + + def create_session(self, username: str, password: str) -> Session: + with session_scope() as session: + row = session.scalar(select(UserRow).where(UserRow.username == username)) + if row is None: + raise AppError( + 401, + "unauthorized", + "Invalid credentials", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) + try: + password_hasher.verify(row.password_hash, password) + except VerifyMismatchError as exc: + raise AppError( + 401, + "unauthorized", + "Invalid credentials", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) from exc + + token = secrets.token_urlsafe(32) + expires_at = utc_now() + timedelta(seconds=session_ttl_seconds()) + session.add( + SessionRow( + token_hash=hash_token(token), + user_id=row.id, + expires_at=expires_at, + created_at=utc_now(), + ) + ) + user = _user_from_row(row) + return Session( + token=token, + token_type="Bearer", + expires_at=format_ts(expires_at), + user=user, + ) + + def resolve_bearer(self, token: str) -> str: + with session_scope() as session: + row = session.get(SessionRow, hash_token(token)) + challenge = {"WWW-Authenticate": 'Bearer realm="messenger"'} + if row is None: + raise AppError(401, "unauthorized", "Invalid session", headers=challenge) + if row.revoked_at is not None: + raise AppError(401, "unauthorized", "Session revoked", headers=challenge) + if _aware(row.expires_at) <= utc_now(): + raise AppError(401, "unauthorized", "Session expired", headers=challenge) + return str(row.user_id) + + def revoke_session(self, token: str) -> None: + with session_scope() as session: + row = session.get(SessionRow, hash_token(token), with_for_update=True) + challenge = {"WWW-Authenticate": 'Bearer realm="messenger"'} + if row is None: + raise AppError(401, "unauthorized", "Invalid session", headers=challenge) + if row.revoked_at is not None: + raise AppError(401, "unauthorized", "Session revoked", headers=challenge) + if _aware(row.expires_at) <= utc_now(): + raise AppError(401, "unauthorized", "Session expired", headers=challenge) + row.revoked_at = utc_now() + + def create_chat(self, title: str, member_ids: List[str]) -> Chat: + chat_id = uuid.uuid4() + member_uuids = [UUID(m) for m in member_ids] + with session_scope() as session: + existing = session.scalar( + select(func.count()).select_from(UserRow).where(UserRow.id.in_(member_uuids)) + ) + if existing != len(member_uuids): + raise AppError(400, "invalid_request", "Unknown member in member_ids") + chat = ChatRow(id=chat_id, title=title, created_at=utc_now()) + session.add(chat) + for member_id in member_uuids: + session.add(ChatMemberRow(chat_id=chat_id, user_id=member_id)) + session.flush() + return _chat_from_row(chat, list(member_ids)) + + def get_chat(self, chat_id: str) -> Optional[Chat]: + with session_scope() as session: + row = session.get(ChatRow, UUID(chat_id)) + if row is None: + return None + return _chat_from_row(row, _member_ids(session, row.id)) + + def list_chats_for_user( + self, + user_id: str, + limit: int, + after: Optional[Tuple[str, str]] = None, + ) -> Tuple[List[Chat], Optional[Chat]]: + with session_scope() as session: + stmt = ( + select(ChatRow) + .join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id) + .where(ChatMemberRow.user_id == UUID(user_id)) + ) + if after is not None: + stmt = stmt.where( + tuple_(ChatRow.created_at, ChatRow.id) + > (parse_ts(after[0]), UUID(after[1])) + ) + stmt = stmt.order_by(ChatRow.created_at.asc(), ChatRow.id.asc()).limit(limit + 1) + rows = list(session.scalars(stmt).all()) + chats = [_chat_from_row(row, _member_ids(session, row.id)) for row in rows] + page = chats[:limit] + has_more = len(chats) > limit + last = page[-1] if page and has_more else None + return page, last + + def create_attachment( + self, + chat_id: str, + owner_id: str, + filename: str, + content_type: str, + data: bytes, + ) -> Attachment: + attachment_id = uuid.uuid4() + object_key = f"attachments/{chat_id}/{attachment_id}" + digest = hashlib.sha256(data).hexdigest() + now = utc_now() + put_object(object_key, data, content_type) + with session_scope() as session: + row = AttachmentRow( + id=attachment_id, + chat_id=UUID(chat_id), + owner_id=UUID(owner_id), + filename=filename, + content_type=content_type, + size_bytes=len(data), + sha256=digest, + object_key=object_key, + status="ready", + error_code=None, + created_at=now, + updated_at=now, + ) + session.add(row) + session.flush() + return _attachment_from_row(row) + + def get_attachment_for_user(self, attachment_id: str, user_id: str) -> Attachment: + with session_scope() as session: + row = session.get(AttachmentRow, UUID(attachment_id)) + if row is None or not _is_chat_member(session, row.chat_id, user_id): + raise AppError(404, "not_found", "Attachment not found") + return _attachment_from_row(row) + + def download_attachment_for_user( + self, attachment_id: str, user_id: str, variant: str = "original" + ) -> Tuple[bytes, str]: + if variant != "original": + raise AppError(400, "invalid_request", "Unsupported variant") + with session_scope() as session: + row = session.get(AttachmentRow, UUID(attachment_id)) + if row is None or not _is_chat_member(session, row.chat_id, user_id): + raise AppError(404, "not_found", "Attachment not found") + if row.status != "ready": + raise AppError(409, "conflict", "Attachment is not ready") + object_key = row.object_key + content_type = row.content_type + return get_object_bytes(object_key), content_type + + def create_message( + self, + chat_id: str, + sender_id: str, + text: str, + attachment_ids: List[str], + *, + idempotency_key: str, + request_path: str, + ) -> Message: + scope = idempotency_scope(sender_id, "POST", request_path, idempotency_key) + body_hash = request_body_hash(text, attachment_ids) + + for _ in range(5): + try: + with session_scope() as session: + existing = session.get(IdempotencyRow, scope, with_for_update=True) + if existing is not None: + if _aware(existing.expires_at) > utc_now(): + if existing.request_hash != body_hash: + raise AppError( + 409, + "conflict", + "Idempotency-Key reused with a different request body", + ) + message = session.get(MessageRow, existing.message_id) + if message is None: + raise AppError(500, "internal_error", "Idempotent message missing") + return _message_from_row(session, message) + session.execute( + delete(IdempotencyRow).where(IdempotencyRow.scope_key == scope) + ) + session.flush() + + attachment_uuids = [UUID(item) for item in attachment_ids] + if attachment_uuids: + rows = list( + session.scalars( + select(AttachmentRow).where(AttachmentRow.id.in_(attachment_uuids)) + ).all() + ) + by_id = {row.id: row for row in rows} + for attachment_id in attachment_uuids: + row = by_id.get(attachment_id) + if row is None or str(row.chat_id) != chat_id: + raise AppError(404, "not_found", "Attachment not found") + if row.status == "failed": + raise AppError(409, "conflict", "Failed attachment cannot be linked") + if row.status != "ready": + raise AppError(409, "conflict", "Attachment is not ready") + + message = MessageRow( + id=uuid.uuid4(), + chat_id=UUID(chat_id), + sender_id=UUID(sender_id), + text=text, + created_at=utc_now(), + ) + session.add(message) + session.flush() + for position, attachment_id in enumerate(attachment_uuids): + session.add( + MessageAttachmentRow( + message_id=message.id, + attachment_id=attachment_id, + position=position, + ) + ) + session.add( + IdempotencyRow( + scope_key=scope, + request_hash=body_hash, + message_id=message.id, + created_at=utc_now(), + expires_at=utc_now() + timedelta(seconds=idempotency_ttl_seconds()), + ) + ) + session.flush() + return _message_from_row(session, message) + except IntegrityError: + continue + + with session_scope() as session: + existing = session.get(IdempotencyRow, scope) + if existing is not None and _aware(existing.expires_at) > utc_now(): + if existing.request_hash != body_hash: + raise AppError( + 409, + "conflict", + "Idempotency-Key reused with a different request body", + ) + message = session.get(MessageRow, existing.message_id) + if message is not None: + return _message_from_row(session, message) + raise AppError(503, "unavailable", "Could not complete idempotent write") + + def list_messages( + self, + chat_id: str, + limit: int, + after: Optional[Tuple[str, str]] = None, + ) -> Tuple[List[Message], Optional[Message]]: + with session_scope() as session: + stmt = select(MessageRow).where(MessageRow.chat_id == UUID(chat_id)) + if after is not None: + stmt = stmt.where( + tuple_(MessageRow.created_at, MessageRow.id) + > (parse_ts(after[0]), UUID(after[1])) + ) + stmt = stmt.order_by(MessageRow.created_at.asc(), MessageRow.id.asc()).limit( + limit + 1 + ) + rows = list(session.scalars(stmt).all()) + messages = [_message_from_row(session, row) for row in rows] + page = messages[:limit] + has_more = len(messages) > limit + last = page[-1] if page and has_more else None + return page, last + + +store = Store() diff --git a/src/messenger/tables.py b/src/messenger/tables.py new file mode 100644 index 00000000..7ff86f02 --- /dev/null +++ b/src/messenger/tables.py @@ -0,0 +1,102 @@ +from __future__ import annotations + +import uuid +from datetime import datetime +from typing import List, Optional + +from sqlalchemy import BigInteger, DateTime, ForeignKey, Integer, String, Text, Uuid +from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship + + +class Base(DeclarativeBase): + pass + + +class UserRow(Base): + __tablename__ = "users" + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True) + username: Mapped[str] = mapped_column(Text, nullable=False, unique=True) + display_name: Mapped[str] = mapped_column(Text, nullable=False) + password_hash: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + + +class ChatRow(Base): + __tablename__ = "chats" + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True) + title: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + members: Mapped[List["ChatMemberRow"]] = relationship(back_populates="chat") + + +class ChatMemberRow(Base): + __tablename__ = "chat_members" + + chat_id: Mapped[uuid.UUID] = mapped_column( + Uuid, ForeignKey("chats.id"), primary_key=True + ) + user_id: Mapped[uuid.UUID] = mapped_column( + Uuid, ForeignKey("users.id"), primary_key=True + ) + chat: Mapped[ChatRow] = relationship(back_populates="members") + + +class MessageRow(Base): + __tablename__ = "messages" + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True) + chat_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("chats.id"), nullable=False) + sender_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), nullable=False) + text: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + + +class MessageAttachmentRow(Base): + __tablename__ = "message_attachments" + + message_id: Mapped[uuid.UUID] = mapped_column( + Uuid, ForeignKey("messages.id"), primary_key=True + ) + attachment_id: Mapped[uuid.UUID] = mapped_column( + Uuid, ForeignKey("attachments.id"), primary_key=True + ) + position: Mapped[int] = mapped_column(Integer, nullable=False) + + +class AttachmentRow(Base): + __tablename__ = "attachments" + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True) + chat_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("chats.id"), nullable=False) + owner_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), nullable=False) + filename: Mapped[str] = mapped_column(Text, nullable=False) + content_type: Mapped[str] = mapped_column(Text, nullable=False) + size_bytes: Mapped[int] = mapped_column(BigInteger, nullable=False) + sha256: Mapped[str] = mapped_column(Text, nullable=False) + object_key: Mapped[str] = mapped_column(Text, nullable=False, unique=True) + status: Mapped[str] = mapped_column(Text, nullable=False) + error_code: Mapped[Optional[str]] = mapped_column(Text, nullable=True) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + + +class SessionRow(Base): + __tablename__ = "sessions" + + token_hash: Mapped[str] = mapped_column(String, primary_key=True) + user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), nullable=False) + expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + revoked_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + + +class IdempotencyRow(Base): + __tablename__ = "idempotency_records" + + scope_key: Mapped[str] = mapped_column(Text, primary_key=True) + request_hash: Mapped[str] = mapped_column(Text, nullable=False) + message_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("messages.id"), nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) -- 2.54.0 From 3a004504ad5cf782be80bcb1cf3ea80710f07ce5 Mon Sep 17 00:00:00 2001 From: Lev_g <177+lev_g@noreply.gitea.privcloud.tech> Date: Thu, 12 Nov 2026 23:09:48 +0300 Subject: [PATCH 2/3] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20REPORT.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index 047913ee..02d4953c 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,7 +2,7 @@ - Автор, группа: Гадяцкий Л. Е., БПИ2302 - Целевая оценка: 3 -- Commit/PR: solution/BPI2302-Gadiatskiy +- Commit/PR: solution/BPI2302-Gadiatskiy MR #121 - Использованные источники и библиотеки: - контракт и семантика: `contracts/openapi.json`, `contracts/README.md`, `README.md`, `COURSE.md` - перенос из lab3: FastAPI, PostgreSQL/сессии, SQLAlchemy, миграции, Nginx LB, идемпотентность -- 2.54.0 From 15469655c83f4ff5d3bec1d1297408918b69de4e Mon Sep 17 00:00:00 2001 From: Lev_g <177+lev_g@noreply.gitea.privcloud.tech> Date: Tue, 17 Nov 2026 00:02:04 +0300 Subject: [PATCH 3/3] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20REPORT.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index 02d4953c..f895d276 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,7 +2,7 @@ - Автор, группа: Гадяцкий Л. Е., БПИ2302 - Целевая оценка: 3 -- Commit/PR: solution/BPI2302-Gadiatskiy MR #121 +- Commit/PR: solution/BPI2302-Gadiatskiy MR#121: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab4/pulls/121 - Использованные источники и библиотеки: - контракт и семантика: `contracts/openapi.json`, `contracts/README.md`, `README.md`, `COURSE.md` - перенос из lab3: FastAPI, PostgreSQL/сессии, SQLAlchemy, миграции, Nginx LB, идемпотентность -- 2.54.0