ЛР2 - Зюлина - на 4 #71
+9
-1
@@ -1,6 +1,14 @@
|
||||
.venv/
|
||||
__pycache__/
|
||||
*.pyc
|
||||
.env
|
||||
.git
|
||||
.github
|
||||
.env
|
||||
tests/
|
||||
student-tests/
|
||||
evidence/
|
||||
examples/
|
||||
*.md
|
||||
.env.*
|
||||
!.env.example
|
||||
secrets
|
||||
|
||||
+5
-9
@@ -1,11 +1,7 @@
|
||||
# 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
|
||||
# Copy to .env and replace the password with a unique local random value.
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=replace-with-a-random-32-character-value
|
||||
POSTGRES_DB=messenger
|
||||
CACHE_URL=redis://redis:6379/0
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
*.pyc
|
||||
# Local/private state
|
||||
.env
|
||||
.env.*
|
||||
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
FROM python:3.11.10-slim-bookworm
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# Устанавливаем зависимости
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Копируем код приложения
|
||||
COPY src/ ./src/
|
||||
COPY alembic/ ./alembic/
|
||||
COPY alembic.ini .
|
||||
COPY entrypoint.sh .
|
||||
|
||||
RUN chmod +x entrypoint.sh
|
||||
|
||||
# Открываем порт
|
||||
EXPOSE 8080
|
||||
|
||||
ENTRYPOINT ["./entrypoint.sh"]
|
||||
|
||||
# Команда запуска
|
||||
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -4,10 +4,11 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
.PHONY: help check validate test load test-persistence test-level4
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "test-level4: Redis, expiry, failures, registration race, rollback, and history index"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -24,3 +25,6 @@ load:
|
||||
test-persistence:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-level4:
|
||||
$(PYTHON) tests/level4.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
@@ -1,37 +1,93 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Зюлина Екатерина Михайловна БВТ2302.
|
||||
- Целевая оценка: **4**.
|
||||
- Использованные источники и помощь: задание, контракт и публичные проверки этого репозитория; помощь Codex при анализе требований, реализации и подготовке отчёта.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
## Воспроизводимый запуск (Windows PowerShell)
|
||||
|
||||
## Архитектура и решения
|
||||
Нужны Docker Desktop с Linux containers и Python 3.11. Приложение собирается из этого репозитория; миграции применяются автоматически при старте API. В новом clone подготовьте виртуальное окружение и локальный `.env`:
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```powershell
|
||||
Copy-Item .env.example .env
|
||||
# В .env заменить POSTGRES_PASSWORD случайным значением длиной не менее 32 символов.
|
||||
py -3.11 -m venv .venv
|
||||
.\.venv\Scripts\python.exe -m pip install -r requirements-dev.txt
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build
|
||||
$ready = $false; $deadline = (Get-Date).AddMinutes(2); while (-not $ready -and (Get-Date) -lt $deadline) { try { $ready = (Invoke-WebRequest http://localhost:8080/health/ready -UseBasicParsing -TimeoutSec 2).StatusCode -eq 200 } catch { Start-Sleep -Seconds 2 } }; if (-not $ready) { throw 'API did not become ready' }
|
||||
.\.venv\Scripts\python.exe scripts\check_contract.py
|
||||
.\.venv\Scripts\python.exe scripts\validate_openapi.py
|
||||
.\.venv\Scripts\python.exe tests\smoke.py --base-url http://localhost:8080
|
||||
.\.venv\Scripts\python.exe tests\resilience.py --mode persistence --action-script scripts\restart.bat --base-url http://localhost:8080
|
||||
.\.venv\Scripts\python.exe tests\level4.py --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
## Доказательства критериев
|
||||
`scripts/restart.bat` перезапускает PostgreSQL, Redis и API без удаления volumes. Не выполняйте `docker compose down -v`, пока данные нужны: эта команда намеренно удаляет сохраняемые данные. Секреты находятся только в локальном игнорируемом `.env`.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
## Архитектура и инфраструктура
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
Путь запроса: клиент → FastAPI → PostgreSQL; Redis используется API для активных сессий. PostgreSQL — **источник истины** для пользователей, хешей паролей, сессий и предметных данных (чаты, участники, сообщения). Redis — TTL-кэш сессий, не единственное хранилище токенов. Volume `postgres_data` сохраняет PostgreSQL; `redis_data` сохраняет AOF Redis. Оба хранилища подключены только во внутреннюю Compose-сеть; наружу опубликован порт API.
|
||||
|
||||
## Эксперименты и отказы
|
||||
| Роль | Compose service / образ | Готовность и постоянные данные |
|
||||
| --- | --- | --- |
|
||||
| HTTP API | `api`, собирается из `Dockerfile`, `python:3.11.10-slim-bookworm` | `/health/ready` проверяет БД и Redis; исходники поставляются с репозиторием. Порт на хосте задаёт `APP_PORT` (по умолчанию 8080). |
|
||||
| SQL-хранилище | `db`, `postgres:16.4-alpine` | `pg_isready`; именованный `postgres_data`; порт 5432 не публикуется на хост. |
|
||||
| Кэш сессий | `redis`, `redis:7.4.2-alpine` | `PING`; именованный `redis_data`; AOF и `appendfsync always`; порт 6379 не публикуется на хост. |
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Compose использует внутренний DNS сервисов `db` и `redis`. Пароль PostgreSQL передаётся API и БД из `.env`; у Redis credentials не заданы, так как он доступен только во внутренней сети локального учебного Compose-стенда. Указанные теги образов закреплены, `latest` не используется. На машине проверки: Windows, Docker Desktop Linux Engine 26.1.4 / Compose 2.27.1, Intel Core i5-11320H, 15.8 GiB RAM. Явные CPU/RAM-лимиты контейнеров не устанавливались; результаты плана запроса относятся только к этому локальному стенду.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
Схема создаётся версионируемыми миграциями Alembic: `001` создаёт начальную структуру; `002` укрепляет временные поля, уникальность членства и индексы истории/списка чатов. Entry point ждёт PostgreSQL, затем выполняет `alembic upgrade head`. Повторный запуск не создаёт вторую схему.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
## Модель данных и транзакции
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- `users`: уникальное имя пользователя, display name, соль и результат password KDF; пароль не сохраняется.
|
||||
- `sessions`: уникальный случайный bearer-токен, пользователь и абсолютный срок `expires_at`; внешний ключ связывает с пользователем.
|
||||
- `chats`, `chat_members`: чат и участники; `(chat_id,user_id)` уникален, внешние ключи не допускают отсутствующих владельцев.
|
||||
- `messages`: чат, отправитель, текст и серверное время; внешние ключи связывают сообщение с чатом и пользователем.
|
||||
|
||||
Каждая операция Store открывает свою SQLAlchemy-сессию. Создание чата и всех участников находится в одной транзакции: неизвестный/повторный участник приводит к rollback целиком. Уникальное ограничение username разрешает гонку на стороне PostgreSQL; проигравшая регистрация преобразуется в `409`, а не в дубликат. ORM использует параметры, пул ограничен пятью постоянными и пятью overflow соединениями, заданы `pool_timeout=5`, PostgreSQL `connect_timeout=5` и `statement_timeout=5s`.
|
||||
|
||||
## Пароли, сессии и Redis
|
||||
|
||||
Пароль обрабатывается стандартной библиотекой `hashlib.scrypt`: индивидуальная случайная соль 128 бит, `N=16384`, `r=8`, `p=1`; сравнение хешей constant-time. Это медленный password KDF с солью, а не быстрый checksum. Basic принимается только на `POST /api/v1/auth/sessions`. После успешного входа сервер возвращает opaque bearer-токен с 256 битами случайности; бизнес-endpoint определяют пользователя по действующей серверной сессии, а `X-User-Id` не даёт полномочий.
|
||||
|
||||
При создании сессии строка сначала фиксируется в PostgreSQL, затем копируется в Redis с TTL, равным оставшемуся сроку жизни. Если Redis недоступен при создании, строка удаляется, а клиент получает `503`, чтобы не выдавать сессию без кэша. Проверка токена сначала читает Redis; cache miss обращается к PostgreSQL и заполняет Redis оставшимся TTL. PostgreSQL остаётся авторитетным и позволяет восстановить действующую сессию после потери/перезапуска Redis. Logout удаляет ключ кэша и запись источника истины. TTL не продлевается чтением или рестартом API; просроченная запись не авторизует запрос даже при задержанном физическом удалении строки.
|
||||
|
||||
Redis настроен на AOF с `appendfsync always`. Тест перезапускает Redis без удаления `redis_data`, затем подтверждает, что прежняя действующая сессия работает; отдельный источник истины в PostgreSQL также позволяет пересобрать ключ кэша при cache miss. Быстрая проверка TCP-порта Redis с таймаутом 0.2 секунды позволяет вернуть ограниченную ошибку при остановленном сервисе, не ожидая цикла повторных попыток клиента.
|
||||
|
||||
## Пагинация и индекс истории
|
||||
|
||||
История использует непрозрачный URL-safe cursor, связанный с chat id и содержащий `(created_at,id)`. Следующая страница фильтруется сравнением этой пары и сортируется по ней же; последний элемент предыдущей страницы не повторяется. Составной индекс `ix_messages_chat_created_id(chat_id, created_at, id)` соответствует равенству по чату, диапазону по cursor и порядку выдачи. Между HTTP-запросами нет snapshot-гарантии; контракт гарантирует обход без повторов для неизменной истории.
|
||||
|
||||
Тест создал отдельный синтетический чат с 12 000 сообщениями, выполнил `ANALYZE` и запрос `EXPLAIN (ANALYZE, BUFFERS)` с keyset-диапазоном и `LIMIT 50`. В сохранённом [плане запроса](evidence/history-plan.txt) PostgreSQL выбрал `Index Only Scan using ix_messages_chat_created_id`, прочитал 50 строк; указаны 6 buffer hits и execution time 0.125 ms на итоговом прогоне. Это свидетельствует об использовании подходящего индекса для данного набора и запроса, но не является нагрузочным бенчмарком или обещанием такой задержки на другом окружении.
|
||||
|
||||
## Результаты проверок уровня 3 и 4
|
||||
|
||||
| Требование | Проверка | Результат|
|
||||
| --- | --- | --- |
|
||||
| Контракт и структура проекта | `scripts/check_contract.py` | PASS |
|
||||
| Валидность Compose | `docker compose --env-file .env config --quiet` | PASS |
|
||||
| OpenAPI 3.1 и JSON Schema | `scripts/validate_openapi.py` | PASS, полная валидация; приложение не подменяется тестом схемы |
|
||||
| Сквозной API smoke | `tests/smoke.py --base-url http://localhost:8080` | PASS — `lab2 public API scenario` на итоговой сборке |
|
||||
| Перезапуск БД/API/Redis и сохранение данных/прежнего токена | `tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080` | PASS — данные и действующая сессия подтверждены после выполнения hook на итоговой сборке |
|
||||
| Две одновременные регистрации с одним username | `tests/level4.py` | PASS: ровно `201` и `409` |
|
||||
| Rollback чата с неизвестным участником | `tests/level4.py` | PASS: в списке не осталось частичного чата |
|
||||
| Redis TTL, AOF и отказ сервисов | `tests/level4.py` | PASS: активные ключи в Redis; сессия доступна после restart Redis; при отключении Redis и PostgreSQL readiness и запрос с Bearer дают `503`, после возврата сервисов API снова готов |
|
||||
| Истечение сессии, logout и неверный пароль | `tests/level4.py` | PASS: неверный пароль `401`, logout `204` с последующим `401`, сессия с TTL 2 секунды после ожидания даёт `401` |
|
||||
| История ≥10 000 строк и индексный план | `tests/level4.py` | PASS: 12 000 синтетических строк; keyset-страница 50 записей; план использовал составной индекс, сохранён в `evidence/history-plan.txt` |
|
||||
|
||||
Полный дополнительный сценарий запускается командой:
|
||||
|
||||
```powershell
|
||||
.\.venv\Scripts\python.exe tests\level4.py --base-url http://localhost:8080
|
||||
```
|
||||
|
||||
Он управляет только `api`, `db`, `redis` этой Compose-группы, не удаляет volumes и создаёт уникальные синтетические fixtures. Для проверки истечения временно меняет `SESSION_TTL_SECONDS` в локальном `.env`, затем восстанавливает исходное содержимое файла. 12 000 сообщений и записи сценариев намеренно остаются в учебной БД. Повторный прогон добавляет новый синтетический набор.
|
||||
|
||||
Итог проверки уровня 4: **PASS** на итоговой сборке.
|
||||
|
||||
## Границы решения и вопросы к защите
|
||||
|
||||
Это локальный учебный стенд с синтетическими данными и HTTP на localhost. Basic кодирует, но не шифрует пароль; удалённая демонстрация требует TLS. Один Docker host и один PostgreSQL не обеспечивают HA. AOF `appendfsync always` настраивает локальную политику Redis, но не защищает от потери всего Docker host/диска; устойчивость PostgreSQL зависит от WAL и хранения volume. `EXPLAIN ANALYZE` измерен на одной машине, без повторов/статистического анализа и без сравнения индексов.
|
||||
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
[alembic]
|
||||
script_location = alembic
|
||||
sqlalchemy.url = postgresql://postgres:postgres@db:5432/messenger
|
||||
|
||||
[loggers]
|
||||
keys = root,sqlalchemy,alembic
|
||||
|
||||
[handlers]
|
||||
keys = console
|
||||
|
||||
[formatters]
|
||||
keys = generic
|
||||
|
||||
[logger_root]
|
||||
level = WARN
|
||||
handlers = console
|
||||
qualname =
|
||||
|
||||
[logger_sqlalchemy]
|
||||
level = WARN
|
||||
handlers =
|
||||
qualname = sqlalchemy.engine
|
||||
|
||||
[logger_alembic]
|
||||
level = INFO
|
||||
handlers =
|
||||
qualname = alembic
|
||||
|
||||
[handler_console]
|
||||
class = StreamHandler
|
||||
args = (sys.stderr,)
|
||||
level = NOTSET
|
||||
formatter = generic
|
||||
|
||||
[formatter_generic]
|
||||
format = %(levelname)-5.5s [%(name)s] %(message)s
|
||||
datefmt = %H:%M:%S
|
||||
@@ -0,0 +1,46 @@
|
||||
from logging.config import fileConfig
|
||||
from sqlalchemy import engine_from_config
|
||||
from alembic import context
|
||||
import sys
|
||||
import os
|
||||
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
from src.database import Base, DATABASE_URL
|
||||
|
||||
config = context.config
|
||||
config.set_main_option("sqlalchemy.url", DATABASE_URL)
|
||||
|
||||
if config.config_file_name is not None:
|
||||
fileConfig(config.config_file_name)
|
||||
|
||||
target_metadata = Base.metadata
|
||||
|
||||
|
||||
def run_migrations_offline():
|
||||
url = context.config.get_main_option("sqlalchemy.url")
|
||||
context.configure(
|
||||
url=url,
|
||||
target_metadata=target_metadata,
|
||||
literal_binds=True,
|
||||
dialect_opts={"paramstyle": "named"},
|
||||
)
|
||||
with context.begin_transaction():
|
||||
context.run_migrations()
|
||||
|
||||
|
||||
def run_migrations_online():
|
||||
connectable = engine_from_config(
|
||||
config.get_section(config.config_ini_section),
|
||||
prefix="sqlalchemy.",
|
||||
poolclass=None,
|
||||
)
|
||||
with connectable.connect() as connection:
|
||||
context.configure(connection=connection, target_metadata=target_metadata)
|
||||
with context.begin_transaction():
|
||||
context.run_migrations()
|
||||
|
||||
|
||||
if context.is_offline_mode():
|
||||
run_migrations_offline()
|
||||
else:
|
||||
run_migrations_online()
|
||||
@@ -0,0 +1,22 @@
|
||||
"""${message}
|
||||
|
||||
Revision ID: ${up_revision}
|
||||
Revises: ${down_revision | comma,n}
|
||||
Create Date: ${create_date}
|
||||
"""
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
${imports if imports else ""}
|
||||
|
||||
revision = ${repr(up_revision)}
|
||||
down_revision = ${repr(down_revision)}
|
||||
branch_labels = ${repr(branch_labels)}
|
||||
depends_on = ${repr(depends_on)}
|
||||
|
||||
|
||||
def upgrade():
|
||||
${upgrades if upgrades else "pass"}
|
||||
|
||||
|
||||
def downgrade():
|
||||
${downgrades if downgrades else "pass"}
|
||||
@@ -0,0 +1,70 @@
|
||||
"""Initial schema
|
||||
|
||||
Revision ID: 001
|
||||
Revises:
|
||||
Create Date: 2026-10-12
|
||||
"""
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
revision = '001'
|
||||
down_revision = None
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
||||
def upgrade():
|
||||
op.create_table('users',
|
||||
sa.Column('id', sa.String(), nullable=False),
|
||||
sa.Column('username', sa.String(length=32), nullable=False),
|
||||
sa.Column('display_name', sa.String(length=100), nullable=False),
|
||||
sa.Column('password_hash', sa.String(length=255), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.PrimaryKeyConstraint('id'))
|
||||
op.create_index('ix_users_username', 'users', ['username'], unique=True)
|
||||
|
||||
op.create_table('sessions',
|
||||
sa.Column('id', sa.String(), nullable=False),
|
||||
sa.Column('token', sa.String(length=255), nullable=False),
|
||||
sa.Column('user_id', sa.String(), nullable=False),
|
||||
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.ForeignKeyConstraint(['user_id'], ['users.id']),
|
||||
sa.PrimaryKeyConstraint('id'))
|
||||
op.create_index('ix_sessions_token', 'sessions', ['token'], unique=True)
|
||||
|
||||
op.create_table('chats',
|
||||
sa.Column('id', sa.String(), nullable=False),
|
||||
sa.Column('title', sa.String(length=100), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.PrimaryKeyConstraint('id'))
|
||||
|
||||
op.create_table('chat_members',
|
||||
sa.Column('id', sa.String(), nullable=False),
|
||||
sa.Column('chat_id', sa.String(), nullable=False),
|
||||
sa.Column('user_id', sa.String(), nullable=False),
|
||||
sa.ForeignKeyConstraint(['chat_id'], ['chats.id']),
|
||||
sa.ForeignKeyConstraint(['user_id'], ['users.id']),
|
||||
sa.PrimaryKeyConstraint('id'))
|
||||
|
||||
op.create_table('messages',
|
||||
sa.Column('id', sa.String(), nullable=False),
|
||||
sa.Column('chat_id', sa.String(), nullable=False),
|
||||
sa.Column('sender_id', sa.String(), nullable=False),
|
||||
sa.Column('text', sa.Text(), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.ForeignKeyConstraint(['chat_id'], ['chats.id']),
|
||||
sa.ForeignKeyConstraint(['sender_id'], ['users.id']),
|
||||
sa.PrimaryKeyConstraint('id'))
|
||||
op.create_index('ix_messages_chat_created', 'messages', ['chat_id', 'created_at'])
|
||||
|
||||
|
||||
def downgrade():
|
||||
op.drop_index('ix_messages_chat_created', table_name='messages')
|
||||
op.drop_table('messages')
|
||||
op.drop_table('chat_members')
|
||||
op.drop_table('chats')
|
||||
op.drop_index('ix_sessions_token', table_name='sessions')
|
||||
op.drop_table('sessions')
|
||||
op.drop_index('ix_users_username', table_name='users')
|
||||
op.drop_table('users')
|
||||
@@ -0,0 +1,35 @@
|
||||
"""Add membership uniqueness and the keyset history index.
|
||||
|
||||
Revision ID: 002
|
||||
Revises: 001
|
||||
Create Date: 2026-10-14
|
||||
"""
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
revision = '002'
|
||||
down_revision = '001'
|
||||
branch_labels = None
|
||||
depends_on = None
|
||||
|
||||
|
||||
def upgrade():
|
||||
# Older schemas allowed nullable timestamps. Backfill before tightening the
|
||||
# constraint so the migration also works on an existing populated database.
|
||||
for table in ('users', 'sessions', 'chats', 'messages'):
|
||||
op.execute(sa.text(f'UPDATE {table} SET created_at = CURRENT_TIMESTAMP WHERE created_at IS NULL'))
|
||||
op.alter_column(table, 'created_at', existing_type=sa.DateTime(timezone=True), nullable=False)
|
||||
|
||||
op.create_unique_constraint('uq_chat_member', 'chat_members', ['chat_id', 'user_id'])
|
||||
op.create_index('ix_chat_members_user_chat', 'chat_members', ['user_id', 'chat_id'])
|
||||
op.drop_index('ix_messages_chat_created', table_name='messages')
|
||||
op.create_index('ix_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'])
|
||||
|
||||
|
||||
def downgrade():
|
||||
op.drop_index('ix_messages_chat_created_id', table_name='messages')
|
||||
op.create_index('ix_messages_chat_created', 'messages', ['chat_id', 'created_at'])
|
||||
op.drop_index('ix_chat_members_user_chat', table_name='chat_members')
|
||||
op.drop_constraint('uq_chat_member', 'chat_members', type_='unique')
|
||||
for table in ('users', 'sessions', 'chats', 'messages'):
|
||||
op.alter_column(table, 'created_at', existing_type=sa.DateTime(timezone=True), nullable=True)
|
||||
@@ -0,0 +1,51 @@
|
||||
services:
|
||||
api:
|
||||
build: .
|
||||
environment:
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Create a local .env first}@db:5432/${POSTGRES_DB:-messenger}
|
||||
CACHE_URL: ${CACHE_URL:-redis://redis:6379/0}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
ports:
|
||||
- "${APP_PORT:-8080}:8080"
|
||||
depends_on:
|
||||
db:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
restart: unless-stopped
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"]
|
||||
interval: 10s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
|
||||
db:
|
||||
image: postgres:16.4-alpine
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Create a local .env first}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
|
||||
interval: 5s
|
||||
timeout: 5s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.4.2-alpine
|
||||
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
|
||||
volumes:
|
||||
- redis_data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
redis_data:
|
||||
@@ -0,0 +1,19 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
python - <<'PY'
|
||||
import os, time
|
||||
from sqlalchemy import create_engine, text
|
||||
url = os.environ["DATABASE_URL"]
|
||||
engine = create_engine(url, connect_args={"connect_timeout": 3})
|
||||
for attempt in range(60):
|
||||
try:
|
||||
with engine.connect() as connection:
|
||||
connection.execute(text("SELECT 1"))
|
||||
break
|
||||
except Exception:
|
||||
if attempt == 59:
|
||||
raise
|
||||
time.sleep(1)
|
||||
PY
|
||||
alembic upgrade head
|
||||
exec "$@"
|
||||
@@ -0,0 +1,17 @@
|
||||
Synthetic chat rows: 12000
|
||||
Query: keyset range on (created_at, id), LIMIT 50
|
||||
|
||||
QUERY PLAN
|
||||
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.42..32.35 rows=50 width=45) (actual time=0.038..0.052 rows=50 loops=1)
|
||||
Buffers: shared hit=7
|
||||
-> Index Only Scan using ix_messages_chat_created_id on messages (cost=0.42..959.48 rows=1502 width=45) (actual time=0.037..0.049 rows=50 loops=1)
|
||||
Index Cond: ((chat_id = '16e6e2a6-54aa-4985-b7c0-9f0e0ecb0047'::text) AND (ROW(created_at, id) > ROW((CURRENT_TIMESTAMP - '01:40:00'::interval), ''::text)))
|
||||
Heap Fetches: 50
|
||||
Buffers: shared hit=7
|
||||
Planning:
|
||||
Buffers: shared hit=136
|
||||
Planning Time: 0.620 ms
|
||||
Execution Time: 0.111 ms
|
||||
(10 rows)
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
fastapi==0.109.0
|
||||
uvicorn[standard]==0.27.0
|
||||
pydantic==2.5.3
|
||||
sqlalchemy==2.0.25
|
||||
alembic==1.13.1
|
||||
psycopg2-binary==2.9.9
|
||||
redis==5.0.1
|
||||
@@ -0,0 +1,11 @@
|
||||
@echo off
|
||||
setlocal
|
||||
cd /d "%~dp0.."
|
||||
docker compose --env-file .env restart db
|
||||
if errorlevel 1 exit /b 1
|
||||
docker compose --env-file .env restart redis
|
||||
if errorlevel 1 exit /b 1
|
||||
docker compose --env-file .env restart api
|
||||
if errorlevel 1 exit /b 1
|
||||
powershell -NoProfile -Command "$deadline=(Get-Date).AddSeconds(90); do { try { $r=Invoke-WebRequest -UseBasicParsing http://localhost:8080/health/ready -TimeoutSec 2; if ($r.StatusCode -eq 200) { exit 0 } } catch {}; Start-Sleep -Seconds 2 } while ((Get-Date) -lt $deadline); exit 1"
|
||||
exit /b %ERRORLEVEL%
|
||||
@@ -0,0 +1,16 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart db
|
||||
docker compose --env-file .env up -d --wait db
|
||||
docker compose --env-file .env restart redis
|
||||
docker compose --env-file .env up -d --wait redis
|
||||
docker compose --env-file .env restart api
|
||||
deadline=$(( $(date +%s) + 90 ))
|
||||
until curl --fail --silent http://localhost:8080/health/ready >/dev/null; do
|
||||
if [ "$(date +%s)" -ge "$deadline" ]; then
|
||||
echo "API did not become ready within 90 seconds" >&2
|
||||
exit 1
|
||||
fi
|
||||
sleep 2
|
||||
done
|
||||
@@ -0,0 +1 @@
|
||||
from .main import app
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
"""scrypt password KDF and opaque, cryptographically random bearer tokens."""
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import os
|
||||
import secrets
|
||||
|
||||
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
salt = secrets.token_bytes(16)
|
||||
digest = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=2**14, r=8, p=1, dklen=32)
|
||||
return "scrypt$16384$8$1$" + base64.urlsafe_b64encode(salt + digest).decode("ascii")
|
||||
|
||||
|
||||
def verify_password(password: str, encoded: str) -> bool:
|
||||
try:
|
||||
scheme, n, r, p, raw = encoded.split("$", 4)
|
||||
if scheme != "scrypt":
|
||||
return False
|
||||
data = base64.urlsafe_b64decode(raw.encode("ascii"))
|
||||
salt, expected = data[:16], data[16:]
|
||||
actual = hashlib.scrypt(password.encode("utf-8"), salt=salt, n=int(n), r=int(r), p=int(p), dklen=len(expected))
|
||||
return hmac.compare_digest(actual, expected)
|
||||
except (ValueError, TypeError):
|
||||
return False
|
||||
|
||||
|
||||
def new_token() -> str:
|
||||
return secrets.token_urlsafe(32)
|
||||
@@ -0,0 +1,67 @@
|
||||
"""PostgreSQL schema and bounded connection pool."""
|
||||
import os
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from sqlalchemy import (Column, DateTime, ForeignKey, Index, String, Text,
|
||||
UniqueConstraint, create_engine)
|
||||
from sqlalchemy.orm import declarative_base, relationship, sessionmaker
|
||||
|
||||
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:postgres@db:5432/messenger")
|
||||
engine = create_engine(DATABASE_URL, pool_size=5, max_overflow=5, pool_timeout=5,
|
||||
pool_pre_ping=True, connect_args={"connect_timeout": 5,
|
||||
"options": "-c statement_timeout=5000"})
|
||||
SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
|
||||
Base = declarative_base()
|
||||
now = lambda: datetime.now(timezone.utc)
|
||||
|
||||
|
||||
class User(Base):
|
||||
__tablename__ = "users"
|
||||
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
|
||||
username = Column(String(32), nullable=False)
|
||||
display_name = Column(String(100), nullable=False)
|
||||
password_hash = Column(String(255), nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), nullable=False, default=now)
|
||||
__table_args__ = (Index("ix_users_username", "username", unique=True),)
|
||||
|
||||
|
||||
class Session(Base):
|
||||
__tablename__ = "sessions"
|
||||
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
|
||||
token = Column(String(255), nullable=False)
|
||||
user_id = Column(String, ForeignKey("users.id"), nullable=False)
|
||||
expires_at = Column(DateTime(timezone=True), nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), nullable=False, default=now)
|
||||
user = relationship("User")
|
||||
__table_args__ = (Index("ix_sessions_token", "token", unique=True),)
|
||||
|
||||
|
||||
class Chat(Base):
|
||||
__tablename__ = "chats"
|
||||
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
|
||||
title = Column(String(100), nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), nullable=False, default=now)
|
||||
members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan")
|
||||
|
||||
|
||||
class ChatMember(Base):
|
||||
__tablename__ = "chat_members"
|
||||
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
|
||||
chat_id = Column(String, ForeignKey("chats.id"), nullable=False)
|
||||
user_id = Column(String, ForeignKey("users.id"), nullable=False)
|
||||
chat = relationship("Chat", back_populates="members")
|
||||
user = relationship("User")
|
||||
__table_args__ = (UniqueConstraint("chat_id", "user_id", name="uq_chat_member"),
|
||||
Index("ix_chat_members_user_chat", "user_id", "chat_id"))
|
||||
|
||||
|
||||
class Message(Base):
|
||||
__tablename__ = "messages"
|
||||
id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
|
||||
chat_id = Column(String, ForeignKey("chats.id"), nullable=False)
|
||||
sender_id = Column(String, ForeignKey("users.id"), nullable=False)
|
||||
text = Column(Text, nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), nullable=False, default=now)
|
||||
chat = relationship("Chat")
|
||||
sender = relationship("User")
|
||||
__table_args__ = (Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),)
|
||||
+233
@@ -0,0 +1,233 @@
|
||||
"""Lab 2 REST API: PostgreSQL-backed records and opaque bearer sessions."""
|
||||
import base64
|
||||
import binascii
|
||||
import uuid
|
||||
from datetime import timezone
|
||||
from fastapi import FastAPI, Request, Query
|
||||
from fastapi.responses import JSONResponse
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from sqlalchemy import text
|
||||
from sqlalchemy.exc import SQLAlchemyError
|
||||
from .database import SessionLocal
|
||||
from .models import CreateUser, CreateChat, CreateMessage
|
||||
from .store import store, cursor_for_chat, cursor_for_message
|
||||
from . import session_cache
|
||||
|
||||
|
||||
class AppError(Exception):
|
||||
def __init__(self, status, code, message, headers=None):
|
||||
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger", version="2.0.0")
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def request_headers(request: Request, call_next):
|
||||
request.state.request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = request.state.request_id
|
||||
return response
|
||||
|
||||
|
||||
@app.exception_handler(AppError)
|
||||
async def app_error_handler(request, exc):
|
||||
headers = {"X-Request-Id": request.state.request_id, **exc.headers}
|
||||
return JSONResponse(status_code=exc.status, content={"error":{"code":exc.code,"message":exc.message,"request_id":request.state.request_id}}, headers=headers)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_handler(request, exc):
|
||||
return JSONResponse(status_code=400, content={"error":{"code":"invalid_request","message":"Invalid request","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id})
|
||||
|
||||
|
||||
@app.exception_handler(SQLAlchemyError)
|
||||
async def database_error_handler(request, exc):
|
||||
return JSONResponse(status_code=503, content={"error":{"code":"unavailable","message":"Database unavailable","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id})
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def internal_handler(request, exc):
|
||||
return JSONResponse(status_code=500, content={"error":{"code":"internal_error","message":"Internal server error","request_id":request.state.request_id}}, headers={"X-Request-Id":request.state.request_id})
|
||||
|
||||
|
||||
def stamp(value):
|
||||
if value.tzinfo is None:
|
||||
value = value.replace(tzinfo=timezone.utc)
|
||||
return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def user_json(user):
|
||||
return {"id":user.id,"username":user.username,"display_name":user.display_name,"created_at":stamp(user.created_at)}
|
||||
|
||||
|
||||
def auth_user(request):
|
||||
header = request.headers.get("Authorization", "")
|
||||
if not header.startswith("Bearer ") or not header[7:]:
|
||||
raise AppError(401,"unauthorized","Authentication required",{"WWW-Authenticate":'Bearer realm="messenger"'})
|
||||
try:
|
||||
found = store.get_session_by_token(header[7:])
|
||||
except session_cache.CacheUnavailable:
|
||||
raise AppError(503,"unavailable","Session cache unavailable")
|
||||
except SQLAlchemyError:
|
||||
raise AppError(503,"unavailable","Authentication store unavailable")
|
||||
if not found:
|
||||
raise AppError(401,"unauthorized","Invalid or expired session",{"WWW-Authenticate":'Bearer realm="messenger"'})
|
||||
return found[0]
|
||||
|
||||
|
||||
def chat_json(chat):
|
||||
return {"id":chat.id,"title":chat.title,"member_ids":[m.user_id for m in chat.members],"created_at":stamp(chat.created_at)}
|
||||
|
||||
|
||||
def validate_uuid(value):
|
||||
try:
|
||||
uuid.UUID(value)
|
||||
except (ValueError, AttributeError):
|
||||
raise AppError(400,"invalid_request","Invalid UUID")
|
||||
|
||||
|
||||
@app.get("/health/live")
|
||||
async def live():
|
||||
return {"status":"ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
async def ready():
|
||||
try:
|
||||
with SessionLocal() as db:
|
||||
db.execute(text("SELECT 1"))
|
||||
session_cache.ping()
|
||||
return {"status":"ok"}
|
||||
except session_cache.CacheUnavailable:
|
||||
raise AppError(503,"unavailable","Session cache unavailable")
|
||||
except SQLAlchemyError:
|
||||
raise AppError(503,"unavailable","Database unavailable")
|
||||
|
||||
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
async def register(data: CreateUser):
|
||||
if not data.display_name.strip() or not 12 <= len(data.password) <= 128:
|
||||
raise AppError(400,"invalid_request","Invalid user fields")
|
||||
try:
|
||||
return user_json(store.add_user(data.username,data.display_name,data.password))
|
||||
except ValueError as exc:
|
||||
if str(exc) == "USERNAME_EXISTS":
|
||||
raise AppError(409,"conflict","Username already exists")
|
||||
raise AppError(400,"invalid_request","Invalid user fields")
|
||||
except SQLAlchemyError:
|
||||
raise AppError(503,"unavailable","Database unavailable")
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
async def login(request: Request):
|
||||
header = request.headers.get("Authorization", "")
|
||||
challenge = {'WWW-Authenticate':'Basic realm="messenger", charset="UTF-8"'}
|
||||
if not header.startswith("Basic "):
|
||||
raise AppError(401,"unauthorized","Invalid credentials",challenge)
|
||||
try:
|
||||
decoded = base64.b64decode(header[6:], validate=True).decode("utf-8")
|
||||
username, password = decoded.split(":", 1)
|
||||
except (binascii.Error, UnicodeError, ValueError):
|
||||
raise AppError(401,"unauthorized","Invalid credentials",challenge)
|
||||
try:
|
||||
user = store.verify_user_password(username,password)
|
||||
if not user:
|
||||
raise AppError(401,"unauthorized","Invalid credentials",challenge)
|
||||
session = store.create_session(user.id)
|
||||
return {"token":session.token,"token_type":"Bearer","expires_at":stamp(session.expires_at),"user":user_json(user)}
|
||||
except session_cache.CacheUnavailable:
|
||||
raise AppError(503,"unavailable","Session cache unavailable")
|
||||
except SQLAlchemyError:
|
||||
raise AppError(503,"unavailable","Database unavailable")
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
async def logout(request: Request):
|
||||
auth_user(request)
|
||||
try:
|
||||
store.delete_session(request.headers["Authorization"][7:])
|
||||
except session_cache.CacheUnavailable:
|
||||
raise AppError(503,"unavailable","Session cache unavailable")
|
||||
except SQLAlchemyError:
|
||||
raise AppError(503,"unavailable","Authentication store unavailable")
|
||||
return None
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
async def me(request: Request):
|
||||
user_id = auth_user(request)
|
||||
user = store.get_user_by_id(user_id)
|
||||
if not user:
|
||||
raise AppError(401,"unauthorized","Invalid session",{'WWW-Authenticate':'Bearer realm="messenger"'})
|
||||
return user_json(user)
|
||||
|
||||
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
async def create_chat(data: CreateChat, request: Request):
|
||||
user_id = auth_user(request)
|
||||
if not data.title.strip():
|
||||
raise AppError(400,"invalid_request","Invalid title")
|
||||
try:
|
||||
return chat_json(store.create_chat(data.title,data.member_ids,user_id))
|
||||
except ValueError as exc:
|
||||
if str(exc)=="USER_NOT_FOUND":
|
||||
raise AppError(400,"invalid_request","Unknown member")
|
||||
raise AppError(400,"invalid_request","Invalid members")
|
||||
except SQLAlchemyError:
|
||||
raise AppError(503,"unavailable","Database unavailable")
|
||||
|
||||
|
||||
@app.get("/api/v1/chats")
|
||||
async def list_chats(request: Request, limit: int = Query(50,ge=1,le=100), cursor: str|None=None):
|
||||
user_id=auth_user(request)
|
||||
try:
|
||||
rows=store.get_user_chats(user_id,cursor,limit+1)
|
||||
except ValueError:
|
||||
raise AppError(400,"invalid_request","Invalid cursor")
|
||||
more=len(rows)>limit
|
||||
rows=rows[:limit]
|
||||
return {"items":[chat_json(c) for c in rows],"next_cursor":cursor_for_chat(rows[-1]) if more else None}
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
async def get_chat(chat_id: str, request: Request):
|
||||
user_id=auth_user(request)
|
||||
validate_uuid(chat_id)
|
||||
if not store.is_chat_member(chat_id,user_id):
|
||||
raise AppError(404,"not_found","Chat not found")
|
||||
chat=store.get_chat(chat_id)
|
||||
if not chat:
|
||||
raise AppError(404,"not_found","Chat not found")
|
||||
return chat_json(chat)
|
||||
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
async def create_message(chat_id: str, data: CreateMessage, request: Request):
|
||||
user_id=auth_user(request)
|
||||
validate_uuid(chat_id)
|
||||
if data.text is None or len(data.text)>4000 or not data.text.strip():
|
||||
raise AppError(400,"invalid_request","Invalid message text")
|
||||
try:
|
||||
msg=store.add_message(chat_id,user_id,data.text)
|
||||
return {"id":msg.id,"chat_id":msg.chat_id,"sender_id":msg.sender_id,"text":msg.text,"created_at":stamp(msg.created_at)}
|
||||
except ValueError:
|
||||
raise AppError(404,"not_found","Chat not found")
|
||||
except SQLAlchemyError:
|
||||
raise AppError(503,"unavailable","Database unavailable")
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
async def list_messages(chat_id: str, request: Request, limit: int=Query(50,ge=1,le=100), cursor: str|None=None):
|
||||
user_id=auth_user(request)
|
||||
validate_uuid(chat_id)
|
||||
if not store.is_chat_member(chat_id,user_id):
|
||||
raise AppError(404,"not_found","Chat not found")
|
||||
try:
|
||||
rows=store.get_messages(chat_id,cursor,limit+1)
|
||||
except ValueError:
|
||||
raise AppError(400,"invalid_request","Invalid cursor")
|
||||
more=len(rows)>limit
|
||||
rows=rows[:limit]
|
||||
items=[{"id":m.id,"chat_id":m.chat_id,"sender_id":m.sender_id,"text":m.text,"created_at":stamp(m.created_at)} for m in rows]
|
||||
return {"items":items,"next_cursor":cursor_for_message(rows[-1]) if more else None}
|
||||
@@ -0,0 +1,27 @@
|
||||
from pydantic import BaseModel, Field, ConfigDict
|
||||
from typing import List
|
||||
|
||||
|
||||
# ==================== REQUEST MODELS ====================
|
||||
|
||||
class CreateUser(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", str_strip_whitespace=False)
|
||||
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(..., min_length=1, max_length=100)
|
||||
password: str = Field(..., min_length=12, max_length=128)
|
||||
|
||||
|
||||
class CreateChat(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
title: str = Field(..., min_length=1, max_length=100)
|
||||
member_ids: List[str] = Field(..., min_length=1, max_length=100)
|
||||
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
text: str = Field(..., min_length=1, max_length=4000)
|
||||
|
||||
|
||||
class LoginRequest(BaseModel):
|
||||
username: str
|
||||
password: str
|
||||
@@ -0,0 +1,72 @@
|
||||
"""Redis TTL cache for active sessions; PostgreSQL remains authoritative."""
|
||||
import os
|
||||
import socket
|
||||
from urllib.parse import urlparse
|
||||
from redis import Redis
|
||||
from redis.backoff import NoBackoff
|
||||
from redis.exceptions import RedisError
|
||||
from redis.retry import Retry
|
||||
|
||||
CACHE_URL = os.getenv("CACHE_URL", "redis://redis:6379/0")
|
||||
_cache_address = urlparse(CACHE_URL)
|
||||
_cache_host = _cache_address.hostname or "redis"
|
||||
_cache_port = _cache_address.port or (6380 if _cache_address.scheme == "rediss" else 6379)
|
||||
try:
|
||||
_cache_ips = tuple(dict.fromkeys(item[4][0] for item in socket.getaddrinfo(
|
||||
_cache_host, _cache_port, type=socket.SOCK_STREAM)))
|
||||
except OSError:
|
||||
_cache_ips = (_cache_host,)
|
||||
client = Redis.from_url(CACHE_URL, decode_responses=True,
|
||||
socket_connect_timeout=0.2, socket_timeout=0.2,
|
||||
health_check_interval=15, retry=Retry(NoBackoff(), 0))
|
||||
|
||||
|
||||
class CacheUnavailable(Exception):
|
||||
"""The required session cache cannot be reached within its short timeout."""
|
||||
|
||||
|
||||
def _check_port():
|
||||
# Fail fast when the Redis container is stopped. redis-py may otherwise
|
||||
# spend several seconds cycling through connection retries on Docker DNS.
|
||||
try:
|
||||
for address in _cache_ips:
|
||||
try:
|
||||
with socket.create_connection((address, _cache_port), timeout=0.2):
|
||||
return
|
||||
except OSError:
|
||||
continue
|
||||
raise OSError("Redis is not accepting connections")
|
||||
except OSError as exc:
|
||||
raise CacheUnavailable from exc
|
||||
|
||||
|
||||
def get(token: str):
|
||||
try:
|
||||
_check_port()
|
||||
return client.get("session:" + token)
|
||||
except RedisError as exc:
|
||||
raise CacheUnavailable from exc
|
||||
|
||||
|
||||
def put(token: str, user_id: str, ttl_seconds: int):
|
||||
try:
|
||||
_check_port()
|
||||
client.set("session:" + token, user_id, ex=max(1, ttl_seconds))
|
||||
except RedisError as exc:
|
||||
raise CacheUnavailable from exc
|
||||
|
||||
|
||||
def delete(token: str):
|
||||
try:
|
||||
_check_port()
|
||||
client.delete("session:" + token)
|
||||
except RedisError as exc:
|
||||
raise CacheUnavailable from exc
|
||||
|
||||
|
||||
def ping():
|
||||
try:
|
||||
_check_port()
|
||||
return bool(client.ping())
|
||||
except RedisError as exc:
|
||||
raise CacheUnavailable from exc
|
||||
+161
@@ -0,0 +1,161 @@
|
||||
"""Small repository layer; each operation owns and closes its DB transaction."""
|
||||
import base64
|
||||
import json
|
||||
import uuid
|
||||
from datetime import datetime, timezone, timedelta
|
||||
import math
|
||||
from sqlalchemy import and_, or_
|
||||
from sqlalchemy.orm import selectinload
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from .database import User, Session as SessionRow, Chat, ChatMember, Message, SessionLocal
|
||||
from .auth import hash_password, verify_password, new_token, SESSION_TTL_SECONDS
|
||||
from . import session_cache
|
||||
|
||||
|
||||
class Store:
|
||||
def add_user(self, username, display_name, password):
|
||||
with SessionLocal() as db:
|
||||
user = User(username=username, display_name=display_name, password_hash=hash_password(password))
|
||||
db.add(user)
|
||||
try:
|
||||
db.commit()
|
||||
except IntegrityError:
|
||||
db.rollback()
|
||||
raise ValueError("USERNAME_EXISTS")
|
||||
db.refresh(user)
|
||||
return user
|
||||
|
||||
def get_user_by_id(self, user_id):
|
||||
with SessionLocal() as db:
|
||||
return db.query(User).filter(User.id == user_id).first()
|
||||
|
||||
def verify_user_password(self, username, password):
|
||||
with SessionLocal() as db:
|
||||
user = db.query(User).filter(User.username == username).first()
|
||||
# A fixed dummy hash is avoided here; the public contract only requires
|
||||
# identical response status and challenge for unknown users/bad passwords.
|
||||
if not user or not verify_password(password, user.password_hash):
|
||||
return None
|
||||
return user
|
||||
|
||||
def create_session(self, user_id):
|
||||
with SessionLocal() as db:
|
||||
row = SessionRow(token=new_token(), user_id=user_id,
|
||||
expires_at=datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS))
|
||||
db.add(row)
|
||||
db.commit()
|
||||
db.refresh(row)
|
||||
try:
|
||||
session_cache.put(row.token, row.user_id, SESSION_TTL_SECONDS)
|
||||
except session_cache.CacheUnavailable:
|
||||
db.delete(row)
|
||||
db.commit()
|
||||
raise
|
||||
return row
|
||||
|
||||
def get_session_by_token(self, token):
|
||||
cached_user_id = session_cache.get(token)
|
||||
if cached_user_id:
|
||||
return (cached_user_id, None)
|
||||
with SessionLocal() as db:
|
||||
row = db.query(SessionRow).filter(SessionRow.token == token,
|
||||
SessionRow.expires_at > datetime.now(timezone.utc)).first()
|
||||
if not row:
|
||||
return None
|
||||
remaining = math.ceil((row.expires_at - datetime.now(timezone.utc)).total_seconds())
|
||||
session_cache.put(row.token, row.user_id, remaining)
|
||||
return (row.user_id, row.expires_at)
|
||||
|
||||
def delete_session(self, token):
|
||||
# Require successful cache invalidation before reporting a completed logout.
|
||||
session_cache.delete(token)
|
||||
with SessionLocal() as db:
|
||||
row = db.query(SessionRow).filter(SessionRow.token == token).first()
|
||||
if row:
|
||||
db.delete(row)
|
||||
db.commit()
|
||||
return True
|
||||
return False
|
||||
|
||||
def create_chat(self, title, member_ids, creator_id):
|
||||
if creator_id not in member_ids:
|
||||
raise ValueError("CREATOR_NOT_MEMBER")
|
||||
if len(member_ids) != len(set(member_ids)):
|
||||
raise ValueError("DUPLICATE_MEMBER")
|
||||
with SessionLocal() as db:
|
||||
users = db.query(User.id).filter(User.id.in_(member_ids)).all()
|
||||
if len(users) != len(member_ids):
|
||||
raise ValueError("USER_NOT_FOUND")
|
||||
chat = Chat(title=title)
|
||||
chat.members = [ChatMember(user_id=mid) for mid in member_ids]
|
||||
db.add(chat)
|
||||
db.commit()
|
||||
db.refresh(chat)
|
||||
list(chat.members)
|
||||
return chat
|
||||
|
||||
def get_chat(self, chat_id):
|
||||
with SessionLocal() as db:
|
||||
return db.query(Chat).options(selectinload(Chat.members)).filter(Chat.id == chat_id).first()
|
||||
|
||||
def get_user_chats(self, user_id, cursor=None, limit=50):
|
||||
with SessionLocal() as db:
|
||||
query = db.query(Chat).options(selectinload(Chat.members)).join(ChatMember).filter(ChatMember.user_id == user_id)
|
||||
if cursor:
|
||||
decoded = decode_cursor(cursor, "chats")
|
||||
query = query.filter(or_(Chat.created_at > decoded[0], and_(Chat.created_at == decoded[0], Chat.id > decoded[1])))
|
||||
rows = query.order_by(Chat.created_at, Chat.id).limit(limit).all()
|
||||
for row in rows:
|
||||
list(row.members)
|
||||
return rows
|
||||
|
||||
def is_chat_member(self, chat_id, user_id):
|
||||
with SessionLocal() as db:
|
||||
return db.query(ChatMember.id).filter(ChatMember.chat_id == chat_id, ChatMember.user_id == user_id).first() is not None
|
||||
|
||||
def add_message(self, chat_id, sender_id, text):
|
||||
with SessionLocal() as db:
|
||||
if not db.query(Chat.id).filter(Chat.id == chat_id).first():
|
||||
raise ValueError("CHAT_NOT_FOUND")
|
||||
if not db.query(ChatMember.id).filter(ChatMember.chat_id == chat_id, ChatMember.user_id == sender_id).first():
|
||||
raise ValueError("NOT_MEMBER")
|
||||
msg = Message(chat_id=chat_id, sender_id=sender_id, text=text)
|
||||
db.add(msg)
|
||||
db.commit()
|
||||
db.refresh(msg)
|
||||
return msg
|
||||
|
||||
def get_messages(self, chat_id, cursor=None, limit=50):
|
||||
with SessionLocal() as db:
|
||||
query = db.query(Message).filter(Message.chat_id == chat_id)
|
||||
if cursor:
|
||||
created, message_id = decode_cursor(cursor, chat_id)
|
||||
query = query.filter(or_(Message.created_at > created,
|
||||
and_(Message.created_at == created, Message.id > message_id)))
|
||||
return query.order_by(Message.created_at, Message.id).limit(limit).all()
|
||||
|
||||
|
||||
def encode_cursor(resource, created_at, item_id):
|
||||
raw = json.dumps([resource, created_at.isoformat(), item_id], separators=(",", ":")).encode()
|
||||
return base64.urlsafe_b64encode(raw).decode().rstrip("=")
|
||||
|
||||
|
||||
def decode_cursor(cursor, resource):
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4)))
|
||||
if data[0] != resource:
|
||||
raise ValueError
|
||||
return datetime.fromisoformat(data[1]), data[2]
|
||||
except Exception:
|
||||
raise ValueError("INVALID_CURSOR")
|
||||
|
||||
|
||||
def cursor_for_chat(chat):
|
||||
return encode_cursor("chats", chat.created_at, chat.id)
|
||||
|
||||
|
||||
def cursor_for_message(message):
|
||||
return encode_cursor(message.chat_id, message.created_at, message.id)
|
||||
|
||||
|
||||
store = Store()
|
||||
@@ -24,6 +24,16 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
|
||||
Тест создаёт данные и сессию, запускает указанный файл без shell interpolation, ожидает готовности и проверяет те же данные **с прежним токеном**. В lab4+ также проверяется исходный файл. Hook может работать до 90 секунд, готовность затем ожидается до 90 секунд. TTL сессии для этого теста — минимум 300 секунд. Успех не доказывает, что hook действительно перезапустил БД: приложите команды/состояния контейнеров до и после.
|
||||
|
||||
## Дополнительные проверки уровня 4, lab2
|
||||
|
||||
Стенд должен быть запущен через Compose с Redis, а локальный `.env` — содержать корректные настройки. Проверка управляет только сервисами `redis`, `db` и `api` этой Compose-группы; Docker volume не удаляется. Используются уникальные синтетические пользователи и чат, а индексный сценарий добавляет 12 000 синтетических сообщений в PostgreSQL. Эти fixtures остаются в стенде для возможности осмотра.
|
||||
|
||||
```sh
|
||||
make test-level4 BASE_URL=http://localhost:8080
|
||||
```
|
||||
|
||||
Сценарий автоматически проверяет гонку двух одинаковых регистраций, отсутствие частичного чата при ошибке состава участников, наличие ключей сессий в Redis, неверный пароль, logout, истечение сессии при TTL=2 секунды, поведение API при остановке Redis и PostgreSQL, восстановление существующей сессии после restart Redis, а также `EXPLAIN (ANALYZE, BUFFERS)` keyset-запроса на 12 000 строк. Во время короткого TTL сценария скрипт временно меняет `SESSION_TTL_SECONDS` в локальном `.env`, перезапускает API и восстанавливает исходный файл даже при ошибке теста. План сохраняется в `evidence/history-plan.txt`.
|
||||
|
||||
## Проверка отказа, lab3+
|
||||
|
||||
Реализуйте `scripts/stop-one.sh` на основе примера. `TARGET_INSTANCE_ID` в окружении содержит alias обслужившей тест API-реплики: сопоставьте его своему контейнеру/Swarm task и остановите именно его. Скрипт должен быстро вернуть 0 и **оставить эту реплику остановленной**; восстановление выполняйте отдельно. Swarm может создать новую task с другим ID — это допустимо.
|
||||
|
||||
+228
@@ -0,0 +1,228 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Automated lab 2 level-4 checks; operates only on synthetic test records."""
|
||||
import base64
|
||||
import concurrent.futures
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
from client import Client, Failure, arguments, check, run
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
ENV_FILE = ROOT / '.env'
|
||||
|
||||
|
||||
def compose(*args, check_ok=True):
|
||||
result = subprocess.run(['docker', 'compose', '--env-file', '.env', *args],
|
||||
cwd=ROOT, capture_output=True, text=True)
|
||||
if check_ok and result.returncode:
|
||||
raise Failure('docker compose operation failed: ' + ' '.join(args))
|
||||
return result
|
||||
|
||||
|
||||
def wait_ready(client, timeout=90):
|
||||
deadline = time.monotonic() + timeout
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
client.call('GET', '/health/ready', schema='Health')
|
||||
return
|
||||
except Failure:
|
||||
time.sleep(0.5)
|
||||
raise Failure('API did not recover within the readiness deadline')
|
||||
|
||||
|
||||
def parse_env(raw):
|
||||
result = {}
|
||||
for line in raw.decode('ascii').splitlines():
|
||||
if '=' in line and not line.lstrip().startswith('#'):
|
||||
key, value = line.split('=', 1)
|
||||
result[key] = value
|
||||
return result
|
||||
|
||||
|
||||
def write_env(values):
|
||||
ENV_FILE.write_text(''.join(f'{key}={value}\n' for key, value in values.items()), encoding='ascii')
|
||||
|
||||
|
||||
def registration_race(client):
|
||||
username = 'race_' + uuid.uuid4().hex[:16]
|
||||
body = {'username': username, 'display_name': 'Concurrent synthetic user',
|
||||
'password': 'Race-Pass-' + uuid.uuid4().hex}
|
||||
|
||||
def post_once():
|
||||
request = urllib.request.Request(client.base + '/api/v1/users',
|
||||
data=json.dumps(body).encode('utf-8'),
|
||||
headers={'Content-Type': 'application/json'}, method='POST')
|
||||
opener = urllib.request.build_opener()
|
||||
try:
|
||||
response = opener.open(request, timeout=10)
|
||||
except urllib.error.HTTPError as error:
|
||||
response = error
|
||||
with response:
|
||||
return response.status
|
||||
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
|
||||
statuses = sorted(executor.map(lambda _: post_once(), range(2)))
|
||||
check(statuses == [201, 409], 'concurrent duplicate registration was not serialized')
|
||||
|
||||
|
||||
def list_all_chats(client, actor):
|
||||
path = '/api/v1/chats?limit=100'
|
||||
rows = []
|
||||
while True:
|
||||
page = client.call('GET', path, actor=actor, schema='ChatPage')['json']
|
||||
rows.extend(page['items'])
|
||||
if page['next_cursor'] is None:
|
||||
return rows
|
||||
from urllib.parse import quote
|
||||
path = '/api/v1/chats?limit=100&cursor=' + quote(page['next_cursor'], safe='')
|
||||
|
||||
|
||||
def database_sql(sql, variables=None):
|
||||
values = parse_env(ENV_FILE.read_bytes())
|
||||
args = ['docker', 'compose', '--env-file', '.env', 'exec', '-T', 'db',
|
||||
'psql', '-U', values['POSTGRES_USER'], '-d', values['POSTGRES_DB'],
|
||||
'-v', 'ON_ERROR_STOP=1']
|
||||
for name, value in (variables or {}).items():
|
||||
args.extend(['-v', name + '=' + value])
|
||||
result = subprocess.run(args, cwd=ROOT, input=sql, capture_output=True, text=True)
|
||||
if result.returncode:
|
||||
raise Failure('database verification query failed')
|
||||
return result.stdout
|
||||
|
||||
|
||||
def internal_status(path, token=None):
|
||||
# During an unhealthy dependency state Docker Desktop may stop forwarding
|
||||
# the published host port. Probe the API loopback from its own container.
|
||||
code = """
|
||||
import os, sys, urllib.request, urllib.error
|
||||
request = urllib.request.Request('http://127.0.0.1:8080' + sys.argv[1])
|
||||
token = os.getenv('CHECK_TOKEN')
|
||||
if token:
|
||||
request.add_header('Authorization', 'Bearer ' + token)
|
||||
try:
|
||||
response = urllib.request.urlopen(request, timeout=30)
|
||||
print(response.status)
|
||||
except urllib.error.HTTPError as error:
|
||||
print(error.code)
|
||||
"""
|
||||
command = ['docker', 'compose', '--env-file', '.env', 'exec', '-T']
|
||||
if token:
|
||||
command.extend(['-e', 'CHECK_TOKEN=' + token])
|
||||
command.extend(['api', 'python', '-', path])
|
||||
result = subprocess.run(command, cwd=ROOT, input=code, capture_output=True, text=True, timeout=32)
|
||||
if result.returncode:
|
||||
raise Failure('in-container dependency probe failed: ' + result.stderr[-500:])
|
||||
return int(result.stdout.strip().splitlines()[-1])
|
||||
|
||||
|
||||
def check_index_plan(client, actor):
|
||||
chat = client.call('POST', '/api/v1/chats', 201, actor=actor,
|
||||
body={'title': 'synthetic index plan', 'member_ids': [actor['id']]}, schema='Chat')['json']
|
||||
seed_sql = """
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid()::text, :'chat_id', :'sender_id', 'plan-probe-' || n,
|
||||
CURRENT_TIMESTAMP - interval '12000 seconds' + n * interval '1 second'
|
||||
FROM generate_series(1, 12000) AS n;
|
||||
ANALYZE messages;
|
||||
SELECT count(*) FROM messages WHERE chat_id = :'chat_id';
|
||||
"""
|
||||
seeded = database_sql(seed_sql, {'chat_id': chat['id'], 'sender_id': actor['id']})
|
||||
check('12000' in {line.strip() for line in seeded.splitlines()},
|
||||
'expected 12,000 synthetic history rows')
|
||||
plan_sql = """
|
||||
EXPLAIN (ANALYZE, BUFFERS)
|
||||
SELECT id, created_at FROM messages
|
||||
WHERE chat_id = :'chat_id'
|
||||
AND (created_at, id) > (CURRENT_TIMESTAMP - interval '6000 seconds', '')
|
||||
ORDER BY created_at, id
|
||||
LIMIT 50;
|
||||
"""
|
||||
plan = database_sql(plan_sql, {'chat_id': chat['id']})
|
||||
check('ix_messages_chat_created_id' in plan, 'keyset history plan did not use the composite index')
|
||||
evidence = ROOT / 'evidence' / 'history-plan.txt'
|
||||
evidence.write_text('Synthetic chat rows: 12000\nQuery: keyset range on (created_at, id), LIMIT 50\n\n' + plan,
|
||||
encoding='utf-8')
|
||||
page = client.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=50',
|
||||
actor=actor, schema='MessagePage')['json']
|
||||
check(len(page['items']) == 50 and page['next_cursor'], 'keyset history did not return a next page')
|
||||
|
||||
|
||||
def check_dependency_failures(client, actor):
|
||||
compose('stop', 'redis')
|
||||
try:
|
||||
check(internal_status('/health/ready') == 503, 'readiness did not fail when Redis was down')
|
||||
check(internal_status('/api/v1/chats', actor['token']) == 503,
|
||||
'authenticated request did not fail in a bounded way when Redis was down')
|
||||
finally:
|
||||
compose('start', 'redis')
|
||||
wait_ready(client)
|
||||
# Redis AOF plus PostgreSQL source of truth must preserve/rebuild this session.
|
||||
client.call('GET', '/api/v1/users/me', actor=actor, schema='User')
|
||||
|
||||
compose('stop', 'db')
|
||||
try:
|
||||
check(internal_status('/health/ready') == 503, 'readiness did not fail when PostgreSQL was down')
|
||||
check(internal_status('/api/v1/chats', actor['token']) == 503,
|
||||
'authenticated request did not fail when PostgreSQL was down')
|
||||
finally:
|
||||
compose('start', 'db')
|
||||
wait_ready(client)
|
||||
client.call('GET', '/api/v1/users/me', actor=actor, schema='User')
|
||||
|
||||
|
||||
def check_short_ttl(client):
|
||||
saved_env = ENV_FILE.read_bytes()
|
||||
values = parse_env(saved_env)
|
||||
try:
|
||||
values['SESSION_TTL_SECONDS'] = '2'
|
||||
write_env(values)
|
||||
compose('up', '-d', '--force-recreate', 'api')
|
||||
wait_ready(client)
|
||||
actor = client.user('expiry')
|
||||
time.sleep(3)
|
||||
client.call('GET', '/api/v1/users/me', 401, actor=actor)
|
||||
finally:
|
||||
ENV_FILE.write_bytes(saved_env)
|
||||
compose('up', '-d', '--force-recreate', 'api')
|
||||
wait_ready(client)
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Lab 2 level-4 concurrency, rollback, expiry, failure, and index checks')
|
||||
client = Client(args.base_url, args.ca_file, timeout=5)
|
||||
wait_ready(client)
|
||||
alice, bob, _eve, chat = client.bootstrap()
|
||||
|
||||
bad = base64.b64encode((alice['registration']['username'] + ':wrong-password').encode()).decode()
|
||||
client.call('POST', '/api/v1/auth/sessions', 401,
|
||||
headers={'Authorization': 'Basic ' + bad})
|
||||
|
||||
registration_race(client)
|
||||
before = {item['id'] for item in list_all_chats(client, alice)}
|
||||
client.call('POST', '/api/v1/chats', 400, actor=alice,
|
||||
body={'title': 'must rollback', 'member_ids': [alice['id'], str(uuid.uuid4())]})
|
||||
after = {item['id'] for item in list_all_chats(client, alice)}
|
||||
check(before == after, 'failed multi-row chat creation left a partial chat')
|
||||
|
||||
cache_size = compose('exec', '-T', 'redis', 'redis-cli', 'DBSIZE').stdout.strip()
|
||||
check(cache_size.isdigit() and int(cache_size) > 0, 'Redis does not contain active session keys')
|
||||
check_dependency_failures(client, bob)
|
||||
check_index_plan(client, alice)
|
||||
|
||||
logout_actor = client.user('logout')
|
||||
client.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=logout_actor)
|
||||
client.call('GET', '/api/v1/users/me', 401, actor=logout_actor)
|
||||
|
||||
check_short_ttl(client)
|
||||
print('PASS: level-4 Redis TTL/recovery, dependency failures, expiry/logout/bad password, '
|
||||
'registration race, chat rollback, and indexed 12,000-row history.')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
Reference in New Issue
Block a user