forked from mtusi2026/mtusi2026lab3
Carry over the lab 2 solution
Bring the application, own tests, Dockerfile, toolchain, compose stack, migrations, secret generator, restart hook, evidence scripts and CI job from the lab 2 solution commit 8cddb09 unchanged, merge the lab 2 Makefile targets into the lab 3 skeleton Makefile without touching its targets, and append the lab 2 solution variables to the skeleton .env.example. The package version follows the contract version 1.3.0. This is the starting point of the lab 3 cycle: lint, own tests and the offline skeleton check pass before any lab 3 change. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude Opus 5.5
parent
0ec2f9dae3
commit
416ce4f9db
@@ -14,7 +14,31 @@ backups
|
||||
*.pfx
|
||||
*.jks
|
||||
.venv
|
||||
venv
|
||||
__pycache__
|
||||
*.pyc
|
||||
*.pyo
|
||||
.pytest_cache
|
||||
.ruff_cache
|
||||
.mypy_cache
|
||||
.ty_cache
|
||||
node_modules
|
||||
evidence
|
||||
openspec
|
||||
student-tests
|
||||
tests
|
||||
scripts
|
||||
examples
|
||||
contracts
|
||||
infra
|
||||
*.md
|
||||
!README.md
|
||||
Makefile
|
||||
Dockerfile*
|
||||
compose*.yaml
|
||||
.dockerignore
|
||||
.gitignore
|
||||
.DS_Store
|
||||
lab.json
|
||||
requirements-dev.txt
|
||||
.claude
|
||||
|
||||
@@ -11,3 +11,8 @@ SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
# Solution-specific: host ports of the API and of the short TTL instance, workers, cursor key file.
|
||||
API_PORT=8080
|
||||
SHORTTTL_PORT=8082
|
||||
WEB_CONCURRENCY=4
|
||||
CURSOR_SECRET_FILE=/run/secrets/cursor_secret
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
name: Application
|
||||
|
||||
on: [push, pull_request]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
quality:
|
||||
name: Линт, типы и собственные тесты
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: astral-sh/setup-uv@v5
|
||||
with:
|
||||
enable-cache: true
|
||||
- run: uv sync --locked --group dev
|
||||
- run: make lint VENV=.venv
|
||||
- run: make student-test VENV=.venv
|
||||
|
||||
acceptance:
|
||||
name: Стенд Compose, smoke, рестарт и отказы зависимостей
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: astral-sh/setup-uv@v5
|
||||
with:
|
||||
enable-cache: true
|
||||
- run: uv sync --locked --group dev
|
||||
|
||||
- name: Поднять стенд из чистого clone
|
||||
run: make up
|
||||
|
||||
- name: Публичный smoke
|
||||
run: make test
|
||||
|
||||
- name: Рестарт API и хранилищ с сохранением volumes
|
||||
run: make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
|
||||
- name: Отказы Valkey и PostgreSQL, expiry, гонка и rollback
|
||||
run: make test-faults
|
||||
|
||||
- name: Процессы работают не от root
|
||||
run: |
|
||||
docker compose top | awk 'NR>1 && $3=="0" {print; bad=1} END {exit bad}'
|
||||
|
||||
- name: Корректная остановка API по SIGTERM
|
||||
run: |
|
||||
start=$(date +%s)
|
||||
docker compose kill --signal SIGTERM api
|
||||
code=$(docker wait "$(docker compose ps -aq api)")
|
||||
elapsed=$(( $(date +%s) - start ))
|
||||
echo "остановка за ${elapsed} с, код завершения ${code}"
|
||||
test "$elapsed" -le 10 && test "$code" = "0"
|
||||
|
||||
- name: Журналы стенда
|
||||
if: always()
|
||||
run: docker compose logs --tail 80
|
||||
+47
@@ -0,0 +1,47 @@
|
||||
FROM python:3.14-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS builder
|
||||
|
||||
COPY --from=ghcr.io/astral-sh/uv:0.9.7@sha256:ba4857bf2a068e9bc0e64eed8563b065908a4cd6bfb66b531a9c424c8e25e142 /uv /usr/local/bin/uv
|
||||
|
||||
ENV UV_COMPILE_BYTECODE=1 \
|
||||
UV_LINK_MODE=copy \
|
||||
UV_PYTHON_DOWNLOADS=never \
|
||||
UV_PROJECT_ENVIRONMENT=/opt/venv
|
||||
|
||||
WORKDIR /build
|
||||
|
||||
COPY pyproject.toml uv.lock README.md ./
|
||||
RUN uv sync --locked --no-dev --no-install-project --no-editable
|
||||
|
||||
COPY src ./src
|
||||
RUN uv sync --locked --no-dev --no-editable
|
||||
|
||||
|
||||
FROM python:3.14-slim-trixie@sha256:51dafde81dbdb6ebde285137a295cf18a47ca95234fe388a343719cb97305b3d AS runtime
|
||||
|
||||
ENV PYTHONUNBUFFERED=1 \
|
||||
PYTHONDONTWRITEBYTECODE=1 \
|
||||
PATH="/opt/venv/bin:$PATH" \
|
||||
HOST=0.0.0.0 \
|
||||
PORT=8080 \
|
||||
LOG_LEVEL=INFO \
|
||||
WEB_CONCURRENCY=4 \
|
||||
REQUEST_TIMEOUT_SECONDS=15 \
|
||||
SHUTDOWN_TIMEOUT_SECONDS=10
|
||||
|
||||
RUN groupadd --system --gid 10001 messenger \
|
||||
&& useradd --system --uid 10001 --gid messenger --no-create-home --shell /usr/sbin/nologin messenger
|
||||
|
||||
COPY --from=builder --chown=root:root /opt/venv /opt/venv
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
USER 10001:10001
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD ["python", "-c", "import urllib.request,sys;sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/live',timeout=2).status==200 else 1)"]
|
||||
|
||||
CMD ["python", "-m", "gunicorn", \
|
||||
"--config", "python:messenger.gunicorn_conf", \
|
||||
"messenger.main:create_app()"]
|
||||
@@ -4,10 +4,21 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
VENV ?= .venv
|
||||
UV ?= uv
|
||||
COMPOSE ?= docker compose
|
||||
PSQL = $(COMPOSE) exec -T postgres psql -U messenger -d messenger -X -q
|
||||
SHORTTTL_PORT ?= 8082
|
||||
SHORTTTL_URL ?= http://localhost:$(SHORTTTL_PORT)
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover \
|
||||
install lint format typecheck student-test \
|
||||
secrets up down reset-data migrate ps logs persistence-evidence storage-evidence cache-evidence test-faults seed explain
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "install/lint/typecheck/student-test: студенческий тулчейн"
|
||||
@echo "secrets/up/down/migrate/ps/logs: стенд Docker Compose; reset-data: намеренное удаление volumes"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -28,3 +39,67 @@ test-persistence:
|
||||
test-failover:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
install:
|
||||
$(UV) sync --group dev
|
||||
|
||||
lint:
|
||||
$(VENV)/bin/ruff check src student-tests
|
||||
$(VENV)/bin/ruff format --check src student-tests
|
||||
$(VENV)/bin/ty check src student-tests
|
||||
|
||||
format:
|
||||
$(VENV)/bin/ruff check --fix src student-tests
|
||||
$(VENV)/bin/ruff format src student-tests
|
||||
|
||||
typecheck:
|
||||
$(VENV)/bin/ty check src student-tests
|
||||
|
||||
student-test:
|
||||
$(VENV)/bin/pytest
|
||||
|
||||
secrets:
|
||||
sh scripts/secrets.sh
|
||||
|
||||
up: secrets
|
||||
$(COMPOSE) up -d --build --wait
|
||||
|
||||
down:
|
||||
$(COMPOSE) --profile faults down
|
||||
|
||||
reset-data:
|
||||
@echo "Удаляются volumes с учебными данными стенда"
|
||||
$(COMPOSE) --profile faults down -v --remove-orphans
|
||||
|
||||
migrate:
|
||||
$(COMPOSE) run --rm migrate
|
||||
|
||||
ps:
|
||||
$(COMPOSE) ps
|
||||
|
||||
logs:
|
||||
$(COMPOSE) logs --tail 200
|
||||
|
||||
persistence-evidence:
|
||||
sh scripts/persistence-evidence.sh "$(BASE_URL)" > evidence/persistence.txt
|
||||
cat evidence/persistence.txt
|
||||
|
||||
storage-evidence:
|
||||
sh scripts/evidence-storage.sh
|
||||
|
||||
cache-evidence:
|
||||
sh scripts/evidence-cache.sh > evidence/cache.txt
|
||||
cat evidence/cache.txt
|
||||
|
||||
test-faults:
|
||||
$(COMPOSE) --profile faults up -d --wait api-shortttl
|
||||
BASE_URL="$(BASE_URL)" SHORTTTL_URL="$(SHORTTTL_URL)" $(VENV)/bin/pytest -m stack -v -s student-tests/stack
|
||||
|
||||
seed:
|
||||
$(PSQL) -f - < scripts/sql/seed-history.sql
|
||||
|
||||
explain: seed
|
||||
{ echo "date: $$(date -u +%FT%TZ) commit: $$(git rev-parse --short HEAD)"; \
|
||||
echo "\$$ make explain # scripts/sql/explain-history.sql"; \
|
||||
$(PSQL) -f - < scripts/sql/explain-history.sql; } > evidence/explain-history.txt
|
||||
cat evidence/explain-history.txt
|
||||
|
||||
+123
@@ -0,0 +1,123 @@
|
||||
x-app: &app
|
||||
image: mtusi-messenger:lab2
|
||||
build: .
|
||||
environment: &app-environment
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
CACHE_URL_FILE: /run/secrets/cache_url
|
||||
CURSOR_SECRET_FILE: /run/secrets/cursor_secret
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
WEB_CONCURRENCY: ${WEB_CONCURRENCY:-4}
|
||||
LOG_LEVEL: ${LOG_LEVEL:-INFO}
|
||||
secrets: [database_url, cache_url, cursor_secret]
|
||||
networks: [backend]
|
||||
|
||||
x-ready: &ready
|
||||
test: ["CMD", "python", "-c", "import urllib.request,sys;sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2).status==200 else 1)"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
start_period: 15s
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:17.11-alpine@sha256:266d3c257594e195b309ae9d1805e54c788f1d7b375f56bf6c367aac6c917e7b
|
||||
user: "70:70"
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets: [postgres_password]
|
||||
volumes: [pgdata:/var/lib/postgresql/data]
|
||||
shm_size: 256m
|
||||
healthcheck:
|
||||
test: ["CMD", "pg_isready", "-h", "127.0.0.1", "-U", "messenger", "-d", "messenger"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
start_period: 10s
|
||||
stop_grace_period: 10s
|
||||
restart: unless-stopped
|
||||
networks: [backend]
|
||||
|
||||
valkey:
|
||||
image: valkey/valkey:8.1.11-alpine@sha256:2602ace2be6569bc2bbb06f873776516ab9089821525be34f4305c67eb9db02a
|
||||
user: "999:1000"
|
||||
command:
|
||||
- valkey-server
|
||||
- /run/secrets/valkey.conf
|
||||
- --appendonly
|
||||
- "yes"
|
||||
- --appendfsync
|
||||
- always
|
||||
- --maxmemory
|
||||
- 64mb
|
||||
- --maxmemory-policy
|
||||
- volatile-lru
|
||||
secrets: [valkey.conf]
|
||||
volumes: [valkeydata:/data]
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(sed -n 's/^requirepass //p' /run/secrets/valkey.conf)\" valkey-cli ping | grep -q PONG"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
stop_grace_period: 10s
|
||||
restart: unless-stopped
|
||||
networks: [backend]
|
||||
|
||||
migrate:
|
||||
<<: *app
|
||||
command: ["python", "-m", "messenger.migrate"]
|
||||
healthcheck:
|
||||
disable: true
|
||||
restart: "no"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
|
||||
api:
|
||||
<<: *app
|
||||
ports: ["127.0.0.1:${API_PORT:-8080}:8080"]
|
||||
healthcheck: *ready
|
||||
stop_grace_period: 10s
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
valkey:
|
||||
condition: service_started
|
||||
|
||||
api-shortttl:
|
||||
<<: *app
|
||||
profiles: [faults]
|
||||
environment:
|
||||
<<: *app-environment
|
||||
SESSION_TTL_SECONDS: "2"
|
||||
WEB_CONCURRENCY: "1"
|
||||
ports: ["127.0.0.1:${SHORTTTL_PORT:-8082}:8080"]
|
||||
healthcheck: *ready
|
||||
stop_grace_period: 10s
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
valkey:
|
||||
condition: service_started
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
valkey.conf:
|
||||
file: ./secrets/valkey.conf
|
||||
cache_url:
|
||||
file: ./secrets/cache_url
|
||||
cursor_secret:
|
||||
file: ./secrets/cursor_secret
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
valkeydata:
|
||||
|
||||
networks:
|
||||
backend:
|
||||
+113
@@ -0,0 +1,113 @@
|
||||
[project]
|
||||
name = "mtusi-messenger"
|
||||
version = "1.3.0"
|
||||
description = "Лабораторная 3 «Балансировка и отказ API-реплики», МТУСИ"
|
||||
requires-python = ">=3.14,<3.15"
|
||||
dependencies = [
|
||||
"fastapi>=0.118.0",
|
||||
"uvicorn[standard]>=0.37.0",
|
||||
"pydantic>=2.11.0",
|
||||
"pydantic-settings>=2.11.0",
|
||||
"dishka>=1.7.0",
|
||||
"structlog>=26.1.0",
|
||||
"gunicorn>=26.2.0",
|
||||
"orjson>=3.12.0",
|
||||
"asyncpg>=0.32.0",
|
||||
"argon2-cffi>=25.1.0",
|
||||
"uvicorn-worker>=0.4.0",
|
||||
"redis>=8.1.0",
|
||||
]
|
||||
|
||||
[dependency-groups]
|
||||
dev = [
|
||||
"pytest>=8.4.0",
|
||||
"pytest-asyncio>=1.2.0",
|
||||
"httpx>=0.28.0",
|
||||
"ruff>=0.14.0",
|
||||
"ty>=0.0.1a21",
|
||||
]
|
||||
|
||||
[build-system]
|
||||
requires = ["hatchling"]
|
||||
build-backend = "hatchling.build"
|
||||
|
||||
[tool.hatch.build.targets.wheel]
|
||||
packages = ["src/messenger"]
|
||||
|
||||
[tool.ruff]
|
||||
line-length = 100
|
||||
target-version = "py314"
|
||||
src = ["src", "student-tests"]
|
||||
extend-exclude = ["tests", "scripts/check_contract.py", "scripts/validate_openapi.py"]
|
||||
per-file-target-version = { "scripts/*.py" = "py39" }
|
||||
|
||||
[tool.ruff.format]
|
||||
indent-style = "space"
|
||||
quote-style = "double"
|
||||
|
||||
[tool.ruff.lint]
|
||||
select = [
|
||||
"E",
|
||||
"W",
|
||||
"F",
|
||||
"I",
|
||||
"N",
|
||||
"UP",
|
||||
"B",
|
||||
"A",
|
||||
"C4",
|
||||
"DTZ",
|
||||
"T20",
|
||||
"SIM",
|
||||
"TID",
|
||||
"PTH",
|
||||
"RUF",
|
||||
"ASYNC",
|
||||
"S",
|
||||
"ARG",
|
||||
"PL",
|
||||
]
|
||||
ignore = [
|
||||
"PLR0913",
|
||||
"RUF001",
|
||||
"RUF002",
|
||||
"RUF003",
|
||||
"S104",
|
||||
"BLE001",
|
||||
]
|
||||
|
||||
[tool.ruff.lint.per-file-ignores]
|
||||
"student-tests/**" = ["S101", "S105", "S106", "S603", "S607", "PLR2004", "ARG001", "T20", "TID251"]
|
||||
"src/messenger/*/infrastructure/**" = ["TID251", "ARG002"]
|
||||
"src/messenger/*/domain/errors.py" = ["N818"]
|
||||
"src/messenger/*/application/errors.py" = ["N818"]
|
||||
"src/messenger/*/entrypoints/**" = ["TID251", "N818", "PLR0917", "S105"]
|
||||
"src/messenger/shared/config.py" = ["ARG002", "ARG003"]
|
||||
"src/messenger/main.py" = ["TID251"]
|
||||
"src/messenger/migrate.py" = ["TID251"]
|
||||
"src/messenger/gunicorn_conf.py" = ["TID251", "ARG002", "RUF012"]
|
||||
|
||||
[tool.ruff.lint.flake8-tidy-imports.banned-api]
|
||||
"messenger.shared.infrastructure".msg = "Домен и слой приложения не импортируют инфраструктуру: зависимость идёт через порт."
|
||||
"messenger.identity.infrastructure".msg = "Домен и слой приложения не импортируют инфраструктуру: зависимость идёт через порт."
|
||||
"messenger.messaging.infrastructure".msg = "Домен и слой приложения не импортируют инфраструктуру: зависимость идёт через порт."
|
||||
|
||||
[tool.ruff.lint.isort]
|
||||
known-first-party = ["messenger"]
|
||||
|
||||
[tool.ty.src]
|
||||
include = ["src", "student-tests"]
|
||||
|
||||
[tool.ty.rules]
|
||||
unresolved-import = "error"
|
||||
invalid-argument-type = "error"
|
||||
possibly-missing-attribute = "warn"
|
||||
|
||||
[tool.pytest.ini_options]
|
||||
testpaths = ["student-tests"]
|
||||
asyncio_mode = "auto"
|
||||
asyncio_default_fixture_loop_scope = "function"
|
||||
addopts = "-q --strict-markers -m 'not stack'"
|
||||
markers = [
|
||||
"stack: black-box проверки против поднятого compose-стенда (make test-faults)",
|
||||
]
|
||||
Executable
+24
@@ -0,0 +1,24 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
cli() { docker compose exec -T valkey sh -c "REDISCLI_AUTH=\"\$(sed -n 's/^requirepass //p' /run/secrets/valkey.conf)\" valkey-cli $1"; }
|
||||
psql() { docker compose exec -T postgres psql -U messenger -d messenger -tA -c "$1"; }
|
||||
echo "date: $(date -u +%FT%TZ) commit: $(git rev-parse --short HEAD)"
|
||||
echo "\$ valkey-cli config get appendonly appendfsync maxmemory maxmemory-policy"
|
||||
cli "config get appendonly" ; cli "config get appendfsync"; cli "config get maxmemory"; cli "config get maxmemory-policy"
|
||||
echo "\$ valkey-cli info persistence | grep aof_enabled,aof_last_write_status"
|
||||
cli "info persistence" | grep -E '^aof_enabled|^aof_last_write_status'
|
||||
echo "\$ valkey-cli dbsize; info stats | grep keyspace"
|
||||
cli dbsize
|
||||
cli "info stats" | grep -E '^keyspace_(hits|misses)'
|
||||
key=$(cli "--scan --pattern session:* --count 1000" | head -1)
|
||||
hash=${key#session:}
|
||||
echo "\$ сравнение срока ключа кэша и срока сессии для одного ключа (значение и токен не печатаются)"
|
||||
echo "valkey pexpiretime, ms: $(cli "pexpiretime $key")"
|
||||
echo "postgres expires_at, ms: $(psql "SELECT (extract(epoch FROM expires_at) * 1000)::bigint FROM sessions WHERE token_hash = decode('$hash', 'hex')")"
|
||||
echo "\$ количество отметок отзыва и закэшированных сессий"
|
||||
revoked=0; cached=0
|
||||
for k in $(cli "--scan --pattern session:* --count 1000"); do
|
||||
if [ "$(cli "get $k")" = "-" ]; then revoked=$((revoked + 1)); else cached=$((cached + 1)); fi
|
||||
done
|
||||
echo "tombstones: $revoked, cached sessions: $cached"
|
||||
Executable
+44
@@ -0,0 +1,44 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
psql() { docker compose exec -T postgres psql -U messenger -d messenger -c "$1"; }
|
||||
header() { echo "date: $(date -u +%FT%TZ) commit: $(git rev-parse --short HEAD)"; }
|
||||
counts="SELECT (SELECT count(*) FROM users) users, (SELECT count(*) FROM sessions) sessions, (SELECT count(*) FROM chats) chats, (SELECT count(*) FROM chat_members) members, (SELECT count(*) FROM messages) messages, (SELECT count(*) FROM schema_migrations) versions"
|
||||
kdf="SELECT substring(password_hash from '^[$]argon2id[$]v=[0-9]+[$]m=[0-9]+,t=[0-9]+,p=[0-9]+[$]') AS kdf_prefix, count(*) AS users, min(length(password_hash)) AS hash_length FROM users GROUP BY 1"
|
||||
tokens="SELECT octet_length(token_hash) AS stored_bytes, count(*) AS sessions FROM sessions GROUP BY 1"
|
||||
{
|
||||
header
|
||||
for table in users sessions chats chat_members messages schema_migrations; do
|
||||
echo "\$ psql -c '\\d+ $table'"
|
||||
psql "\\d+ $table"
|
||||
done
|
||||
echo "\$ psql -c 'SELECT version, left(checksum, 12), applied_at FROM schema_migrations'"
|
||||
psql "SELECT version, left(checksum, 12) AS checksum, applied_at FROM schema_migrations"
|
||||
} > evidence/schema.txt
|
||||
{
|
||||
header
|
||||
echo "\$ psql -c \"$counts\""
|
||||
psql "$counts"
|
||||
echo "\$ make migrate"
|
||||
docker compose run --rm migrate 2>/dev/null
|
||||
echo "\$ psql -c \"$counts\""
|
||||
psql "$counts"
|
||||
} > evidence/migrations.txt
|
||||
{
|
||||
header
|
||||
echo "\$ psql -c \"$kdf\""
|
||||
psql "$kdf"
|
||||
echo "\$ psql -c \"$tokens\""
|
||||
psql "$tokens"
|
||||
} > evidence/kdf.txt
|
||||
{
|
||||
header
|
||||
echo "\$ git ls-files secrets .env backups volumes"
|
||||
git ls-files secrets .env backups volumes
|
||||
echo "(пусто: секретов, .env, дампов и volumes в Git нет)"
|
||||
echo "\$ git check-ignore -v secrets/database_url secrets/postgres_password .env backups/"
|
||||
git check-ignore -v secrets/database_url secrets/postgres_password .env backups/
|
||||
echo "\$ docker volume ls --filter name=mtusi2026lab2"
|
||||
docker volume ls --filter name=mtusi2026lab2
|
||||
} > evidence/secrets.txt
|
||||
echo "evidence/{schema,migrations,kdf,secrets}.txt обновлены"
|
||||
Executable
+17
@@ -0,0 +1,17 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
started() {
|
||||
for service in $(docker compose config --services); do
|
||||
id=$(docker compose ps -aq "$service")
|
||||
if [ -n "$id" ]; then
|
||||
printf '%-10s %s\n' "$service" "$(docker inspect --format '{{.State.StartedAt}} {{.State.Status}}' "$id")"
|
||||
fi
|
||||
done
|
||||
}
|
||||
echo "date: $(date -u +%FT%TZ) commit: $(git rev-parse --short HEAD)"
|
||||
echo "== before: service StartedAt status"
|
||||
started
|
||||
make --no-print-directory test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL="${1:-http://localhost:8080}"
|
||||
echo "== after: service StartedAt status"
|
||||
started
|
||||
Executable
+6
@@ -0,0 +1,6 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose stop api
|
||||
docker compose restart postgres valkey
|
||||
docker compose up -d --wait api
|
||||
Executable
+20
@@ -0,0 +1,20 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
umask 077
|
||||
mkdir -p secrets
|
||||
random() { od -An -N32 -tx1 /dev/urandom | tr -d ' \n'; }
|
||||
put() {
|
||||
if [ ! -s "secrets/$1" ]; then
|
||||
printf '%s' "$2" > "secrets/$1"
|
||||
chmod 644 "secrets/$1"
|
||||
echo "создан secrets/$1"
|
||||
fi
|
||||
}
|
||||
put postgres_password "$(random)"
|
||||
put database_url "postgresql://messenger:$(cat secrets/postgres_password)@postgres:5432/messenger"
|
||||
put cursor_secret "$(random)"
|
||||
put valkey_password "$(random)"
|
||||
put valkey.conf "requirepass $(cat secrets/valkey_password)"
|
||||
put cache_url "redis://:$(cat secrets/valkey_password)@valkey:6379/0"
|
||||
[ -f .env ] || { cp .env.example .env; echo "создан .env из .env.example"; }
|
||||
@@ -0,0 +1,59 @@
|
||||
\set ON_ERROR_STOP on
|
||||
\set big '''00000000-0000-7000-8000-00000000c001'''
|
||||
\set cursor_at '''2026-01-01T02:46:40Z'''
|
||||
\set cursor_id '''00000000-0000-7000-8001-000000002710'''
|
||||
|
||||
PREPARE history_first (uuid, int) AS
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2;
|
||||
|
||||
PREPARE history_after (uuid, timestamptz, uuid, int) AS
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4;
|
||||
|
||||
PREPARE history_offset (uuid, int, int) AS
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2 OFFSET $3;
|
||||
|
||||
SELECT count(*) AS chat_messages FROM messages WHERE chat_id = :big;
|
||||
SELECT count(*) AS all_messages FROM messages;
|
||||
SELECT pg_size_pretty(pg_relation_size('messages_history_idx')) AS history_index_size;
|
||||
|
||||
\echo '== Первая страница, limit=50 (запрос HISTORY_FIRST приложения, LIMIT limit+1)'
|
||||
EXPLAIN (ANALYZE, BUFFERS) EXECUTE history_first(:big, 51);
|
||||
|
||||
\echo '== Глубокая страница: keyset после 10 000-го сообщения (запрос HISTORY_AFTER приложения)'
|
||||
EXPLAIN (ANALYZE, BUFFERS) EXECUTE history_after(:big, :cursor_at, :cursor_id, 51);
|
||||
|
||||
\echo '== Та же глубокая страница через OFFSET 10000 (не используется приложением, для сравнения)'
|
||||
EXPLAIN (ANALYZE, BUFFERS) EXECUTE history_offset(:big, 51, 10000);
|
||||
|
||||
\echo '== Проверка: keyset и OFFSET возвращают одну и ту же страницу'
|
||||
SELECT (
|
||||
SELECT array_agg(id ORDER BY created_at, id) FROM (
|
||||
SELECT id, created_at FROM messages
|
||||
WHERE chat_id = :big AND (created_at, id) > (:cursor_at, :cursor_id)
|
||||
ORDER BY created_at, id LIMIT 51
|
||||
) AS keyset
|
||||
) = (
|
||||
SELECT array_agg(id ORDER BY created_at, id) FROM (
|
||||
SELECT id, created_at FROM messages
|
||||
WHERE chat_id = :big
|
||||
ORDER BY created_at, id LIMIT 51 OFFSET 10000
|
||||
) AS skipped
|
||||
) AS same_page;
|
||||
|
||||
\echo '== Контрольный план без индекса истории (DROP INDEX внутри транзакции, затем ROLLBACK)'
|
||||
BEGIN;
|
||||
DROP INDEX messages_history_idx;
|
||||
EXPLAIN (ANALYZE, BUFFERS) EXECUTE history_after(:big, :cursor_at, :cursor_id, 51);
|
||||
ROLLBACK;
|
||||
@@ -0,0 +1,40 @@
|
||||
\set ON_ERROR_STOP on
|
||||
\set author '''00000000-0000-7000-8000-00000000a001'''
|
||||
\set big '''00000000-0000-7000-8000-00000000c001'''
|
||||
\set epoch '''2026-01-01T00:00:00Z'''
|
||||
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES (:author, 'seed_author', 'Синтетический автор', '$argon2id$v=19$m=19456,t=2,p=1$c2VlZA$c2VlZA', :epoch)
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO chats (id, title, created_at)
|
||||
SELECT ('00000000-0000-7000-8000-00000000c' || lpad(to_hex(chat), 3, '0'))::uuid,
|
||||
'Синтетический чат ' || chat, :epoch
|
||||
FROM generate_series(1, 21) AS chat
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO chat_members (chat_id, user_id, position, chat_created_at)
|
||||
SELECT id, :author, 1, created_at FROM chats WHERE title LIKE 'Синтетический чат %'
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT ('00000000-0000-7000-8001-' || lpad(to_hex(n), 12, '0'))::uuid, :big, :author,
|
||||
'синтетическое сообщение ' || n, :epoch::timestamptz + n * interval '1 second'
|
||||
FROM generate_series(1, 20000) AS n
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT ('00000000-0000-7000-8002-' || lpad(to_hex(chat * 1000 + n), 12, '0'))::uuid,
|
||||
('00000000-0000-7000-8000-00000000c' || lpad(to_hex(chat), 3, '0'))::uuid, :author,
|
||||
'фоновое сообщение ' || n, :epoch::timestamptz + n * interval '1 second'
|
||||
FROM generate_series(2, 21) AS chat, generate_series(1, 500) AS n
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
UPDATE chats
|
||||
SET last_message_at = (SELECT max(created_at) FROM messages WHERE messages.chat_id = chats.id)
|
||||
WHERE title LIKE 'Синтетический чат %';
|
||||
|
||||
ANALYZE;
|
||||
|
||||
SELECT count(*) FILTER (WHERE chat_id = :big) AS big_chat_messages, count(*) AS all_messages
|
||||
FROM messages;
|
||||
@@ -0,0 +1,41 @@
|
||||
import os
|
||||
from typing import Any
|
||||
|
||||
from gunicorn.glogging import Logger as GunicornBaseLogger
|
||||
from uvicorn_worker import UvicornWorker
|
||||
|
||||
from messenger.main import LOG_FIELDS
|
||||
from messenger.shared.infrastructure.logging import configure
|
||||
|
||||
LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO")
|
||||
|
||||
|
||||
class StructlogGunicornLogger(GunicornBaseLogger):
|
||||
def setup(self, cfg: object) -> None:
|
||||
configure(LOG_LEVEL, LOG_FIELDS)
|
||||
|
||||
def access(self, resp: object, req: object, environ: object, request_time: object) -> None:
|
||||
return
|
||||
|
||||
|
||||
class MessengerWorker(UvicornWorker):
|
||||
CONFIG_KWARGS: dict[str, Any] = {
|
||||
"access_log": False,
|
||||
"server_header": False,
|
||||
"date_header": False,
|
||||
"timeout_graceful_shutdown": int(os.environ.get("SHUTDOWN_TIMEOUT_SECONDS", "10")),
|
||||
}
|
||||
|
||||
|
||||
bind = f"{os.environ.get('HOST', '0.0.0.0')}:{os.environ.get('PORT', '8080')}"
|
||||
workers = int(os.environ.get("WEB_CONCURRENCY", "4"))
|
||||
worker_class = "messenger.gunicorn_conf.MessengerWorker"
|
||||
logger_class = StructlogGunicornLogger
|
||||
loglevel = LOG_LEVEL.lower()
|
||||
accesslog = None
|
||||
errorlog = "-"
|
||||
timeout = int(float(os.environ.get("REQUEST_TIMEOUT_SECONDS", "15")) + 5)
|
||||
graceful_timeout = int(os.environ.get("SHUTDOWN_TIMEOUT_SECONDS", "10"))
|
||||
keepalive = 5
|
||||
preload_app = False
|
||||
control_socket_disable = True
|
||||
@@ -0,0 +1,5 @@
|
||||
from messenger.shared.application.messagebus import CommandBus
|
||||
|
||||
|
||||
class IdentityCommandBus(CommandBus):
|
||||
__slots__ = ()
|
||||
@@ -0,0 +1,22 @@
|
||||
from dataclasses import dataclass, field
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.identity.domain.models import Session
|
||||
from messenger.shared.application.commands import Command
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class RegisterUser(Command):
|
||||
username: str
|
||||
display_name: str
|
||||
password: str = field(repr=False)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class OpenSession(Command):
|
||||
user_id: UUID
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class CloseSession(Command):
|
||||
session: Session
|
||||
@@ -0,0 +1,76 @@
|
||||
from datetime import timedelta
|
||||
|
||||
from messenger.identity.application.commands import CloseSession, OpenSession, RegisterUser
|
||||
from messenger.identity.application.ports import (
|
||||
IdentityUnitOfWork,
|
||||
PasswordHasher,
|
||||
SessionDirectory,
|
||||
)
|
||||
from messenger.identity.domain.events import SessionClosed, SessionOpened
|
||||
from messenger.identity.domain.models import Session, User
|
||||
from messenger.identity.domain.values import DisplayName, Password, Username
|
||||
from messenger.shared.application.ports import Clock, IdGenerator
|
||||
|
||||
|
||||
class RegisterUserHandler:
|
||||
__slots__ = ("_clock", "_hasher", "_ids", "_uow")
|
||||
|
||||
def __init__(
|
||||
self, uow: IdentityUnitOfWork, clock: Clock, ids: IdGenerator, hasher: PasswordHasher
|
||||
) -> None:
|
||||
self._uow = uow
|
||||
self._clock = clock
|
||||
self._ids = ids
|
||||
self._hasher = hasher
|
||||
|
||||
async def __call__(self, command: RegisterUser) -> User:
|
||||
username = Username(command.username)
|
||||
display_name = DisplayName(command.display_name)
|
||||
password = Password(command.password)
|
||||
password_hash = await self._hasher.hash(password.value)
|
||||
user, event = User.register(
|
||||
user_id=self._ids.new_id(),
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
password_hash=password_hash,
|
||||
registered_at=self._clock.now(),
|
||||
)
|
||||
async with self._uow.transaction():
|
||||
await self._uow.users.add(user)
|
||||
self._uow.record(event)
|
||||
await self._uow.commit()
|
||||
return user
|
||||
|
||||
|
||||
class OpenSessionHandler:
|
||||
__slots__ = ("_clock", "_ttl", "_uow")
|
||||
|
||||
def __init__(self, uow: IdentityUnitOfWork, clock: Clock, ttl: timedelta) -> None:
|
||||
self._uow = uow
|
||||
self._clock = clock
|
||||
self._ttl = ttl
|
||||
|
||||
async def __call__(self, command: OpenSession) -> tuple[str, Session]:
|
||||
token, session = Session.issue(
|
||||
user_id=command.user_id, issued_at=self._clock.now(), ttl=self._ttl
|
||||
)
|
||||
async with self._uow.transaction():
|
||||
await self._uow.sessions.add(session)
|
||||
self._uow.record(SessionOpened(user_id=session.user_id, expires_at=session.expires_at))
|
||||
await self._uow.commit()
|
||||
return token, session
|
||||
|
||||
|
||||
class CloseSessionHandler:
|
||||
__slots__ = ("_sessions", "_uow")
|
||||
|
||||
def __init__(self, uow: IdentityUnitOfWork, sessions: SessionDirectory) -> None:
|
||||
self._uow = uow
|
||||
self._sessions = sessions
|
||||
|
||||
async def __call__(self, command: CloseSession) -> None:
|
||||
await self._sessions.invalidate(command.session)
|
||||
async with self._uow.transaction():
|
||||
await self._uow.sessions.remove(command.session.token_hash)
|
||||
self._uow.record(SessionClosed(user_id=command.session.user_id))
|
||||
await self._uow.commit()
|
||||
@@ -0,0 +1,48 @@
|
||||
from datetime import datetime
|
||||
from typing import Protocol, runtime_checkable
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.identity.domain.models import Session, User
|
||||
from messenger.shared.application.ports import UnitOfWork
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class UserRepository(Protocol):
|
||||
async def add(self, user: User) -> None: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class SessionRepository(Protocol):
|
||||
async def add(self, session: Session) -> None: ...
|
||||
|
||||
async def remove(self, token_hash: bytes) -> None: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class IdentityUnitOfWork(UnitOfWork, Protocol):
|
||||
@property
|
||||
def users(self) -> UserRepository: ...
|
||||
|
||||
@property
|
||||
def sessions(self) -> SessionRepository: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class UserDirectory(Protocol):
|
||||
async def find(self, user_id: UUID) -> User | None: ...
|
||||
|
||||
async def find_by_username(self, username: str) -> User | None: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class SessionDirectory(Protocol):
|
||||
async def find(self, token_hash: bytes, now: datetime) -> Session | None: ...
|
||||
|
||||
async def invalidate(self, session: Session) -> None: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class PasswordHasher(Protocol):
|
||||
async def hash(self, password: str) -> str: ...
|
||||
|
||||
async def verify(self, password_hash: str | None, password: str) -> bool: ...
|
||||
@@ -0,0 +1,43 @@
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.identity.application.ports import PasswordHasher, SessionDirectory, UserDirectory
|
||||
from messenger.identity.domain.errors import ActorNotIdentified
|
||||
from messenger.identity.domain.models import Session, User, token_digest
|
||||
from messenger.shared.application.ports import Clock
|
||||
|
||||
|
||||
class GetCurrentUser:
|
||||
__slots__ = ("_directory",)
|
||||
|
||||
def __init__(self, directory: UserDirectory) -> None:
|
||||
self._directory = directory
|
||||
|
||||
async def __call__(self, user_id: UUID) -> User:
|
||||
user = await self._directory.find(user_id)
|
||||
if user is None:
|
||||
raise ActorNotIdentified("идентификация не подтверждена")
|
||||
return user
|
||||
|
||||
|
||||
class VerifyCredentials:
|
||||
__slots__ = ("_directory", "_hasher")
|
||||
|
||||
def __init__(self, directory: UserDirectory, hasher: PasswordHasher) -> None:
|
||||
self._directory = directory
|
||||
self._hasher = hasher
|
||||
|
||||
async def __call__(self, username: str, password: str) -> User | None:
|
||||
user = await self._directory.find_by_username(username)
|
||||
valid = await self._hasher.verify(user.password_hash if user else None, password)
|
||||
return user if valid else None
|
||||
|
||||
|
||||
class Authenticate:
|
||||
__slots__ = ("_clock", "_sessions")
|
||||
|
||||
def __init__(self, sessions: SessionDirectory, clock: Clock) -> None:
|
||||
self._sessions = sessions
|
||||
self._clock = clock
|
||||
|
||||
async def __call__(self, token: str) -> Session | None:
|
||||
return await self._sessions.find(token_digest(token), self._clock.now())
|
||||
@@ -0,0 +1,12 @@
|
||||
from pydantic import Field, SecretStr
|
||||
|
||||
from messenger.shared.config import Settings
|
||||
|
||||
|
||||
class IdentitySettings(Settings):
|
||||
session_ttl_seconds: int = Field(default=3600, ge=1, le=30 * 24 * 3600)
|
||||
password_hash_concurrency: int = Field(default=2, ge=1, le=64)
|
||||
cache_url: SecretStr | None = None
|
||||
session_cache_ttl_seconds: int = Field(default=300, ge=1, le=24 * 3600)
|
||||
cache_timeout_seconds: float = Field(default=0.2, gt=0, le=5)
|
||||
cache_cooldown_seconds: float = Field(default=1.0, ge=0, le=60)
|
||||
@@ -0,0 +1,17 @@
|
||||
from messenger.shared.domain.errors import DomainError
|
||||
|
||||
|
||||
class IdentityError(DomainError):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidUserData(IdentityError):
|
||||
pass
|
||||
|
||||
|
||||
class UsernameAlreadyTaken(IdentityError):
|
||||
pass
|
||||
|
||||
|
||||
class ActorNotIdentified(IdentityError):
|
||||
pass
|
||||
@@ -0,0 +1,25 @@
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.shared.domain.events import DomainEvent
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class UserRegistered(DomainEvent):
|
||||
user_id: UUID
|
||||
registered_at: datetime
|
||||
name: str = field(init=False, default="user.registered")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SessionOpened(DomainEvent):
|
||||
user_id: UUID
|
||||
expires_at: datetime
|
||||
name: str = field(init=False, default="session.opened")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SessionClosed(DomainEvent):
|
||||
user_id: UUID
|
||||
name: str = field(init=False, default="session.closed")
|
||||
@@ -0,0 +1,62 @@
|
||||
import secrets
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timedelta
|
||||
from hashlib import sha256
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.identity.domain.events import UserRegistered
|
||||
from messenger.identity.domain.values import DisplayName, Username
|
||||
from messenger.shared.domain.events import DomainEvent
|
||||
|
||||
TOKEN_BYTES = 32
|
||||
|
||||
|
||||
def token_digest(token: str) -> bytes:
|
||||
return sha256(token.encode()).digest()
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class User:
|
||||
id: UUID
|
||||
username: Username
|
||||
display_name: DisplayName
|
||||
created_at: datetime
|
||||
password_hash: str = field(repr=False)
|
||||
|
||||
@classmethod
|
||||
def register(
|
||||
cls,
|
||||
*,
|
||||
user_id: UUID,
|
||||
username: Username,
|
||||
display_name: DisplayName,
|
||||
password_hash: str,
|
||||
registered_at: datetime,
|
||||
) -> tuple[User, DomainEvent]:
|
||||
user = cls(
|
||||
id=user_id,
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
created_at=registered_at,
|
||||
password_hash=password_hash,
|
||||
)
|
||||
return user, UserRegistered(user_id=user.id, registered_at=registered_at)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Session:
|
||||
token_hash: bytes = field(repr=False)
|
||||
user_id: UUID
|
||||
created_at: datetime
|
||||
expires_at: datetime
|
||||
|
||||
@classmethod
|
||||
def issue(cls, *, user_id: UUID, issued_at: datetime, ttl: timedelta) -> tuple[str, Session]:
|
||||
token = secrets.token_urlsafe(TOKEN_BYTES)
|
||||
session = cls(
|
||||
token_hash=token_digest(token),
|
||||
user_id=user_id,
|
||||
created_at=issued_at,
|
||||
expires_at=issued_at + ttl,
|
||||
)
|
||||
return token, session
|
||||
@@ -0,0 +1,54 @@
|
||||
import re
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
from messenger.identity.domain.errors import InvalidUserData
|
||||
|
||||
USERNAME_PATTERN = re.compile(r"\A[a-z0-9_]{3,32}\Z")
|
||||
DISPLAY_NAME_MAX = 100
|
||||
PASSWORD_MIN = 12
|
||||
PASSWORD_MAX = 128
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Username:
|
||||
value: str
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not isinstance(self.value, str):
|
||||
raise InvalidUserData("поле username должно быть строкой")
|
||||
if USERNAME_PATTERN.match(self.value) is None:
|
||||
raise InvalidUserData("поле username должно соответствовать [a-z0-9_]{3,32}")
|
||||
|
||||
def __str__(self) -> str:
|
||||
return self.value
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DisplayName:
|
||||
value: str
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not isinstance(self.value, str):
|
||||
raise InvalidUserData("поле display_name должно быть строкой")
|
||||
if not self.value.strip():
|
||||
raise InvalidUserData("поле display_name не может быть пустым или состоять из пробелов")
|
||||
if len(self.value) > DISPLAY_NAME_MAX:
|
||||
raise InvalidUserData(f"поле display_name длиннее {DISPLAY_NAME_MAX} символов Unicode")
|
||||
|
||||
def __str__(self) -> str:
|
||||
return self.value
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Password:
|
||||
value: str = field(repr=False)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not isinstance(self.value, str):
|
||||
raise InvalidUserData("поле password должно быть строкой")
|
||||
if not self.value.strip():
|
||||
raise InvalidUserData("поле password не может состоять из пробелов")
|
||||
if not PASSWORD_MIN <= len(self.value) <= PASSWORD_MAX:
|
||||
raise InvalidUserData(
|
||||
f"поле password: от {PASSWORD_MIN} до {PASSWORD_MAX} символов Unicode"
|
||||
)
|
||||
@@ -0,0 +1,98 @@
|
||||
import re
|
||||
from base64 import b64decode
|
||||
from binascii import Error as Base64Error
|
||||
from typing import Annotated
|
||||
|
||||
from fastapi import Depends, Request
|
||||
from starlette.types import Scope
|
||||
|
||||
from messenger.identity.application.queries import Authenticate, VerifyCredentials
|
||||
from messenger.identity.domain.models import Session, User
|
||||
from messenger.shared.entrypoints.errors import Unauthenticated
|
||||
from messenger.shared.entrypoints.pipeline import Rejection, header
|
||||
|
||||
LOGIN_PATH = "/api/v1/auth/sessions"
|
||||
PROTECTED_PREFIX = "/api/v1/"
|
||||
PUBLIC_ROUTES = frozenset({("POST", "/api/v1/users")})
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
AUTHORIZATION = b"authorization"
|
||||
TOKEN = re.compile(r"[A-Za-z0-9\-._~+/]{1,512}=*")
|
||||
|
||||
|
||||
def normalized(path: str) -> str:
|
||||
return path.rstrip("/") or "/"
|
||||
|
||||
|
||||
def challenge_for(path: str) -> str:
|
||||
return BASIC_CHALLENGE if normalized(path) == LOGIN_PATH else BEARER_CHALLENGE
|
||||
|
||||
|
||||
def basic_credentials(value: str) -> tuple[str, str] | None:
|
||||
scheme, _, encoded = value.partition(" ")
|
||||
if scheme.lower() != "basic":
|
||||
return None
|
||||
try:
|
||||
decoded = b64decode(encoded.strip(), validate=True).decode("utf-8")
|
||||
except Base64Error, UnicodeDecodeError:
|
||||
return None
|
||||
username, separator, password = decoded.partition(":")
|
||||
if not separator or not username.isascii():
|
||||
return None
|
||||
return username, password
|
||||
|
||||
|
||||
def bearer_token(value: str) -> str | None:
|
||||
scheme, _, token = value.partition(" ")
|
||||
token = token.strip()
|
||||
if scheme.lower() != "bearer" or TOKEN.fullmatch(token) is None:
|
||||
return None
|
||||
return token
|
||||
|
||||
|
||||
def rejection(path: str) -> Rejection:
|
||||
return Rejection(401, "unauthorized", (("www-authenticate", challenge_for(path)),))
|
||||
|
||||
|
||||
async def guard(scope: Scope) -> Rejection | None:
|
||||
method, path = scope["method"], normalized(scope["path"])
|
||||
if not path.startswith(PROTECTED_PREFIX) or (method, path) in PUBLIC_ROUTES:
|
||||
return None
|
||||
container = scope["app"].state.dishka_container
|
||||
state = scope.setdefault("state", {})
|
||||
raw = header(scope, AUTHORIZATION)
|
||||
if (method, path) == ("POST", LOGIN_PATH):
|
||||
credentials = basic_credentials(raw)
|
||||
verify = await container.get(VerifyCredentials)
|
||||
user = await verify(*credentials) if credentials else None
|
||||
if user is None:
|
||||
return rejection(path)
|
||||
state["user"] = user
|
||||
state["actor"] = user.id
|
||||
return None
|
||||
token = bearer_token(raw)
|
||||
authenticate = await container.get(Authenticate)
|
||||
session = await authenticate(token) if token else None
|
||||
if session is None:
|
||||
return rejection(path)
|
||||
state["session"] = session
|
||||
state["actor"] = session.user_id
|
||||
return None
|
||||
|
||||
|
||||
async def verified_user(request: Request) -> User:
|
||||
user = getattr(request.state, "user", None)
|
||||
if not isinstance(user, User):
|
||||
raise Unauthenticated("учётные данные не подтверждены")
|
||||
return user
|
||||
|
||||
|
||||
async def current_session(request: Request) -> Session:
|
||||
session = getattr(request.state, "session", None)
|
||||
if not isinstance(session, Session):
|
||||
raise Unauthenticated("сессия не подтверждена")
|
||||
return session
|
||||
|
||||
|
||||
type VerifiedUser = Annotated[User, Depends(verified_user)]
|
||||
type CurrentSession = Annotated[Session, Depends(current_session)]
|
||||
@@ -0,0 +1,12 @@
|
||||
from messenger.identity.domain.errors import (
|
||||
ActorNotIdentified,
|
||||
InvalidUserData,
|
||||
UsernameAlreadyTaken,
|
||||
)
|
||||
from messenger.shared.domain.errors import DomainError
|
||||
|
||||
ERROR_CODES: dict[type[DomainError], tuple[str, int]] = {
|
||||
InvalidUserData: ("invalid_request", 400),
|
||||
UsernameAlreadyTaken: ("conflict", 409),
|
||||
ActorNotIdentified: ("unauthorized", 401),
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
from dishka.integrations.fastapi import FromDishka, inject
|
||||
from fastapi import APIRouter, Request, Response, status
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
|
||||
from messenger.identity.application.bus import IdentityCommandBus
|
||||
from messenger.identity.application.commands import CloseSession, OpenSession, RegisterUser
|
||||
from messenger.identity.application.queries import GetCurrentUser
|
||||
from messenger.identity.entrypoints.authentication import CurrentSession, VerifiedUser
|
||||
from messenger.identity.entrypoints.schemas import CreateUserRequest, SessionOut, UserOut
|
||||
from messenger.shared.entrypoints.actor import Actor
|
||||
|
||||
router = APIRouter(prefix="/api/v1/users", tags=["users"])
|
||||
sessions_router = APIRouter(prefix="/api/v1/auth/sessions", tags=["sessions"])
|
||||
|
||||
|
||||
@router.post("", status_code=status.HTTP_201_CREATED)
|
||||
@inject
|
||||
async def create_user(
|
||||
body: CreateUserRequest,
|
||||
bus: FromDishka[IdentityCommandBus],
|
||||
) -> UserOut:
|
||||
user = await bus.execute(
|
||||
RegisterUser(username=body.username, display_name=body.display_name, password=body.password)
|
||||
)
|
||||
return UserOut.of(user)
|
||||
|
||||
|
||||
@router.get("/me")
|
||||
@inject
|
||||
async def current_user(
|
||||
actor: Actor,
|
||||
query: FromDishka[GetCurrentUser],
|
||||
) -> UserOut:
|
||||
return UserOut.of(await query(actor))
|
||||
|
||||
|
||||
@sessions_router.post("", status_code=status.HTTP_201_CREATED)
|
||||
@inject
|
||||
async def open_session(
|
||||
request: Request,
|
||||
user: VerifiedUser,
|
||||
bus: FromDishka[IdentityCommandBus],
|
||||
) -> SessionOut:
|
||||
if await request.body():
|
||||
raise RequestValidationError([])
|
||||
token, session = await bus.execute(OpenSession(user_id=user.id))
|
||||
return SessionOut.of(token, session, user)
|
||||
|
||||
|
||||
@sessions_router.delete("/current", status_code=status.HTTP_204_NO_CONTENT)
|
||||
@inject
|
||||
async def close_session(
|
||||
session: CurrentSession,
|
||||
bus: FromDishka[IdentityCommandBus],
|
||||
) -> Response:
|
||||
await bus.execute(CloseSession(session=session))
|
||||
return Response(status_code=status.HTTP_204_NO_CONTENT)
|
||||
@@ -0,0 +1,112 @@
|
||||
from collections.abc import AsyncIterator
|
||||
from datetime import timedelta
|
||||
|
||||
from dishka import Provider, Scope, provide
|
||||
from redis.asyncio import Redis
|
||||
from redis.asyncio.retry import Retry
|
||||
from redis.backoff import NoBackoff
|
||||
|
||||
from messenger.identity.application.bus import IdentityCommandBus
|
||||
from messenger.identity.application.commands import CloseSession, OpenSession, RegisterUser
|
||||
from messenger.identity.application.handlers import (
|
||||
CloseSessionHandler,
|
||||
OpenSessionHandler,
|
||||
RegisterUserHandler,
|
||||
)
|
||||
from messenger.identity.application.ports import (
|
||||
IdentityUnitOfWork,
|
||||
PasswordHasher,
|
||||
SessionDirectory,
|
||||
UserDirectory,
|
||||
)
|
||||
from messenger.identity.application.queries import Authenticate, GetCurrentUser, VerifyCredentials
|
||||
from messenger.identity.config import IdentitySettings
|
||||
from messenger.identity.infrastructure.argon2 import Argon2PasswordHasher
|
||||
from messenger.identity.infrastructure.postgres import (
|
||||
PostgresIdentityUnitOfWork,
|
||||
PostgresSessionDirectory,
|
||||
PostgresUserDirectory,
|
||||
)
|
||||
from messenger.identity.infrastructure.valkey import CachedSessionDirectory
|
||||
from messenger.shared.application.commands import Command
|
||||
from messenger.shared.application.messagebus import CommandHandler
|
||||
from messenger.shared.application.ports import Clock, EventPublisher, IdGenerator, Logger
|
||||
from messenger.shared.infrastructure.postgres import Database
|
||||
|
||||
|
||||
class IdentityProvider(Provider):
|
||||
def __init__(self, settings: IdentitySettings) -> None:
|
||||
super().__init__()
|
||||
self._settings = settings
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def settings(self) -> IdentitySettings:
|
||||
return self._settings
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def hasher(self, settings: IdentitySettings) -> PasswordHasher:
|
||||
return Argon2PasswordHasher(settings.password_hash_concurrency)
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def users(self, database: Database) -> UserDirectory:
|
||||
return PostgresUserDirectory(database)
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
async def sessions(
|
||||
self, database: Database, settings: IdentitySettings, logger: Logger
|
||||
) -> AsyncIterator[SessionDirectory]:
|
||||
origin = PostgresSessionDirectory(database)
|
||||
if settings.cache_url is None:
|
||||
yield origin
|
||||
return
|
||||
client = Redis.from_url(
|
||||
settings.cache_url.get_secret_value(),
|
||||
socket_connect_timeout=settings.cache_timeout_seconds,
|
||||
socket_timeout=settings.cache_timeout_seconds,
|
||||
retry=Retry(NoBackoff(), 1),
|
||||
)
|
||||
try:
|
||||
yield CachedSessionDirectory(
|
||||
origin,
|
||||
client,
|
||||
logger,
|
||||
limit=timedelta(seconds=settings.session_cache_ttl_seconds),
|
||||
cooldown=settings.cache_cooldown_seconds,
|
||||
)
|
||||
finally:
|
||||
await client.aclose()
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def verify(self, users: UserDirectory, hasher: PasswordHasher) -> VerifyCredentials:
|
||||
return VerifyCredentials(users, hasher)
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def authenticate(self, sessions: SessionDirectory, clock: Clock) -> Authenticate:
|
||||
return Authenticate(sessions, clock)
|
||||
|
||||
@provide(scope=Scope.REQUEST)
|
||||
def unit_of_work(self, database: Database) -> IdentityUnitOfWork:
|
||||
return PostgresIdentityUnitOfWork(database)
|
||||
|
||||
@provide(scope=Scope.REQUEST)
|
||||
def current_user(self, users: UserDirectory) -> GetCurrentUser:
|
||||
return GetCurrentUser(users)
|
||||
|
||||
@provide(scope=Scope.REQUEST)
|
||||
def command_bus(
|
||||
self,
|
||||
uow: IdentityUnitOfWork,
|
||||
publisher: EventPublisher,
|
||||
clock: Clock,
|
||||
ids: IdGenerator,
|
||||
hasher: PasswordHasher,
|
||||
sessions: SessionDirectory,
|
||||
settings: IdentitySettings,
|
||||
) -> IdentityCommandBus:
|
||||
ttl = timedelta(seconds=settings.session_ttl_seconds)
|
||||
handlers: dict[type[Command], CommandHandler] = {
|
||||
RegisterUser: RegisterUserHandler(uow, clock, ids, hasher),
|
||||
OpenSession: OpenSessionHandler(uow, clock, ttl),
|
||||
CloseSession: CloseSessionHandler(uow, sessions),
|
||||
}
|
||||
return IdentityCommandBus(handlers, uow, publisher)
|
||||
@@ -0,0 +1,20 @@
|
||||
from messenger.identity.domain.events import SessionClosed, SessionOpened, UserRegistered
|
||||
from messenger.shared.application.ports import Logger
|
||||
|
||||
LOG_FIELDS = frozenset({"actor_id"})
|
||||
|
||||
|
||||
class IdentityJournal:
|
||||
__slots__ = ("_logger",)
|
||||
|
||||
def __init__(self, logger: Logger) -> None:
|
||||
self._logger = logger
|
||||
|
||||
async def on_user_registered(self, event: UserRegistered) -> None:
|
||||
self._logger.info("audit.user_registered", actor_id=str(event.user_id))
|
||||
|
||||
async def on_session_opened(self, event: SessionOpened) -> None:
|
||||
self._logger.info("audit.session_opened", actor_id=str(event.user_id))
|
||||
|
||||
async def on_session_closed(self, event: SessionClosed) -> None:
|
||||
self._logger.info("audit.session_closed", actor_id=str(event.user_id))
|
||||
@@ -0,0 +1,42 @@
|
||||
from datetime import datetime
|
||||
from typing import Literal
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
|
||||
from messenger.identity.domain.models import Session, User
|
||||
|
||||
|
||||
class CreateUserRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
username: str
|
||||
display_name: str
|
||||
password: str
|
||||
|
||||
|
||||
class UserOut(BaseModel):
|
||||
id: UUID
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: datetime
|
||||
|
||||
@classmethod
|
||||
def of(cls, user: User) -> UserOut:
|
||||
return cls(
|
||||
id=user.id,
|
||||
username=user.username.value,
|
||||
display_name=user.display_name.value,
|
||||
created_at=user.created_at,
|
||||
)
|
||||
|
||||
|
||||
class SessionOut(BaseModel):
|
||||
token: str
|
||||
token_type: Literal["Bearer"] = "Bearer"
|
||||
expires_at: datetime
|
||||
user: UserOut
|
||||
|
||||
@classmethod
|
||||
def of(cls, token: str, session: Session, user: User) -> SessionOut:
|
||||
return cls(token=token, expires_at=session.expires_at, user=UserOut.of(user))
|
||||
@@ -0,0 +1,35 @@
|
||||
import asyncio
|
||||
import secrets
|
||||
|
||||
from argon2 import PasswordHasher, Type
|
||||
from argon2.exceptions import InvalidHashError, VerificationError
|
||||
|
||||
TIME_COST = 2
|
||||
MEMORY_COST_KIB = 19_456
|
||||
PARALLELISM = 1
|
||||
|
||||
|
||||
class Argon2PasswordHasher:
|
||||
__slots__ = ("_dummy", "_hasher", "_slots")
|
||||
|
||||
def __init__(self, concurrency: int) -> None:
|
||||
self._hasher = PasswordHasher(
|
||||
time_cost=TIME_COST,
|
||||
memory_cost=MEMORY_COST_KIB,
|
||||
parallelism=PARALLELISM,
|
||||
type=Type.ID,
|
||||
)
|
||||
self._slots = asyncio.Semaphore(concurrency)
|
||||
self._dummy = self._hasher.hash(secrets.token_urlsafe(16))
|
||||
|
||||
async def hash(self, password: str) -> str:
|
||||
async with self._slots:
|
||||
return await asyncio.to_thread(self._hasher.hash, password)
|
||||
|
||||
async def verify(self, password_hash: str | None, password: str) -> bool:
|
||||
async with self._slots:
|
||||
try:
|
||||
await asyncio.to_thread(self._hasher.verify, password_hash or self._dummy, password)
|
||||
except VerificationError, InvalidHashError:
|
||||
return False
|
||||
return password_hash is not None
|
||||
@@ -0,0 +1,124 @@
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from asyncpg import Record
|
||||
|
||||
from messenger.identity.domain.errors import UsernameAlreadyTaken
|
||||
from messenger.identity.domain.models import Session, User
|
||||
from messenger.identity.domain.values import DisplayName, Username
|
||||
from messenger.shared.infrastructure.postgres import Connection, Database, PostgresUnitOfWork
|
||||
|
||||
INSERT_USER = """
|
||||
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
ON CONFLICT (username) DO NOTHING
|
||||
RETURNING true
|
||||
"""
|
||||
USER_BY_ID = """
|
||||
SELECT id, username, display_name, password_hash, created_at FROM users WHERE id = $1
|
||||
"""
|
||||
USER_BY_USERNAME = """
|
||||
SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1
|
||||
"""
|
||||
INSERT_SESSION = """
|
||||
WITH expired AS (DELETE FROM sessions WHERE user_id = $2 AND expires_at <= $3)
|
||||
INSERT INTO sessions (token_hash, user_id, created_at, expires_at) VALUES ($1, $2, $3, $4)
|
||||
"""
|
||||
DELETE_SESSION = "DELETE FROM sessions WHERE token_hash = $1"
|
||||
ACTIVE_SESSION = """
|
||||
SELECT token_hash, user_id, created_at, expires_at
|
||||
FROM sessions
|
||||
WHERE token_hash = $1 AND expires_at > $2
|
||||
"""
|
||||
|
||||
|
||||
def user_of(row: Record | None) -> User | None:
|
||||
if row is None:
|
||||
return None
|
||||
return User(
|
||||
id=row["id"],
|
||||
username=Username(row["username"]),
|
||||
display_name=DisplayName(row["display_name"]),
|
||||
created_at=row["created_at"],
|
||||
password_hash=row["password_hash"],
|
||||
)
|
||||
|
||||
|
||||
class PostgresUserRepository:
|
||||
__slots__ = ("_connection",)
|
||||
|
||||
def __init__(self, connection: Connection) -> None:
|
||||
self._connection = connection
|
||||
|
||||
async def add(self, user: User) -> None:
|
||||
inserted = await self._connection.fetchval(
|
||||
INSERT_USER,
|
||||
user.id,
|
||||
user.username.value,
|
||||
user.display_name.value,
|
||||
user.password_hash,
|
||||
user.created_at,
|
||||
)
|
||||
if inserted is None:
|
||||
raise UsernameAlreadyTaken("username уже занят")
|
||||
|
||||
|
||||
class PostgresSessionRepository:
|
||||
__slots__ = ("_connection",)
|
||||
|
||||
def __init__(self, connection: Connection) -> None:
|
||||
self._connection = connection
|
||||
|
||||
async def add(self, session: Session) -> None:
|
||||
await self._connection.execute(
|
||||
INSERT_SESSION,
|
||||
session.token_hash,
|
||||
session.user_id,
|
||||
session.created_at,
|
||||
session.expires_at,
|
||||
)
|
||||
|
||||
async def remove(self, token_hash: bytes) -> None:
|
||||
await self._connection.execute(DELETE_SESSION, token_hash)
|
||||
|
||||
|
||||
class PostgresIdentityUnitOfWork(PostgresUnitOfWork):
|
||||
__slots__ = ()
|
||||
|
||||
@property
|
||||
def users(self) -> PostgresUserRepository:
|
||||
return PostgresUserRepository(self.connection)
|
||||
|
||||
@property
|
||||
def sessions(self) -> PostgresSessionRepository:
|
||||
return PostgresSessionRepository(self.connection)
|
||||
|
||||
|
||||
class PostgresUserDirectory:
|
||||
__slots__ = ("_database",)
|
||||
|
||||
def __init__(self, database: Database) -> None:
|
||||
self._database = database
|
||||
|
||||
async def find(self, user_id: UUID) -> User | None:
|
||||
async with self._database.connection() as connection:
|
||||
return user_of(await connection.fetchrow(USER_BY_ID, user_id))
|
||||
|
||||
async def find_by_username(self, username: str) -> User | None:
|
||||
async with self._database.connection() as connection:
|
||||
return user_of(await connection.fetchrow(USER_BY_USERNAME, username))
|
||||
|
||||
|
||||
class PostgresSessionDirectory:
|
||||
__slots__ = ("_database",)
|
||||
|
||||
def __init__(self, database: Database) -> None:
|
||||
self._database = database
|
||||
|
||||
async def find(self, token_hash: bytes, now: datetime) -> Session | None:
|
||||
async with self._database.connection() as connection:
|
||||
row = await connection.fetchrow(ACTIVE_SESSION, token_hash, now)
|
||||
return None if row is None else Session(**dict(row))
|
||||
|
||||
async def invalidate(self, session: Session) -> None:
|
||||
return None
|
||||
@@ -0,0 +1,102 @@
|
||||
import time
|
||||
from collections.abc import Awaitable
|
||||
from datetime import datetime, timedelta
|
||||
from uuid import UUID
|
||||
|
||||
from redis.asyncio import Redis
|
||||
from redis.exceptions import RedisError
|
||||
|
||||
from messenger.identity.application.ports import SessionDirectory
|
||||
from messenger.identity.domain.models import Session
|
||||
from messenger.shared.application.errors import Unavailable
|
||||
from messenger.shared.application.ports import Logger
|
||||
|
||||
REVOKED = "-"
|
||||
FAILURES = (RedisError, OSError)
|
||||
|
||||
|
||||
def key_of(token_hash: bytes) -> str:
|
||||
return f"session:{token_hash.hex()}"
|
||||
|
||||
|
||||
def milliseconds(moment: datetime) -> int:
|
||||
return int(moment.timestamp() * 1000)
|
||||
|
||||
|
||||
def encode(session: Session) -> str:
|
||||
return f"{session.user_id} {session.created_at.isoformat()} {session.expires_at.isoformat()}"
|
||||
|
||||
|
||||
def decode(token_hash: bytes, value: str) -> Session:
|
||||
user_id, created_at, expires_at = value.split(" ")
|
||||
return Session(
|
||||
token_hash=token_hash,
|
||||
user_id=UUID(user_id),
|
||||
created_at=datetime.fromisoformat(created_at),
|
||||
expires_at=datetime.fromisoformat(expires_at),
|
||||
)
|
||||
|
||||
|
||||
class CachedSessionDirectory:
|
||||
__slots__ = ("_client", "_cooldown", "_limit", "_logger", "_origin", "_resume_at")
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
origin: SessionDirectory,
|
||||
client: Redis,
|
||||
logger: Logger,
|
||||
*,
|
||||
limit: timedelta,
|
||||
cooldown: float,
|
||||
) -> None:
|
||||
self._origin = origin
|
||||
self._client = client
|
||||
self._logger = logger
|
||||
self._limit = limit
|
||||
self._cooldown = cooldown
|
||||
self._resume_at = 0.0
|
||||
|
||||
async def find(self, token_hash: bytes, now: datetime) -> Session | None:
|
||||
key = key_of(token_hash)
|
||||
cached = await self._read(key)
|
||||
if cached == REVOKED:
|
||||
return None
|
||||
if cached is not None:
|
||||
session = decode(token_hash, cached)
|
||||
return session if session.expires_at > now else None
|
||||
session = await self._origin.find(token_hash, now)
|
||||
if session is not None and self._closed():
|
||||
until = milliseconds(min(session.expires_at, now + self._limit))
|
||||
await self._quietly(self._client.set(key, encode(session), pxat=until, nx=True))
|
||||
return session
|
||||
|
||||
async def invalidate(self, session: Session) -> None:
|
||||
if not self._closed():
|
||||
raise Unavailable("кэш сессий недоступен")
|
||||
try:
|
||||
await self._client.set(
|
||||
key_of(session.token_hash), REVOKED, pxat=milliseconds(session.expires_at)
|
||||
)
|
||||
except FAILURES as error:
|
||||
self._trip(error)
|
||||
raise Unavailable("кэш сессий недоступен") from error
|
||||
|
||||
async def _read(self, key: str) -> str | None:
|
||||
if not self._closed():
|
||||
return None
|
||||
value = await self._quietly(self._client.get(key))
|
||||
return value.decode() if isinstance(value, bytes) else value
|
||||
|
||||
async def _quietly[ResultT](self, call: Awaitable[ResultT]) -> ResultT | None:
|
||||
try:
|
||||
return await call
|
||||
except FAILURES as error:
|
||||
self._trip(error)
|
||||
return None
|
||||
|
||||
def _closed(self) -> bool:
|
||||
return time.monotonic() >= self._resume_at
|
||||
|
||||
def _trip(self, error: Exception) -> None:
|
||||
self._resume_at = time.monotonic() + self._cooldown
|
||||
self._logger.warning("cache.bypassed", error=type(error).__name__, limit=self._cooldown)
|
||||
@@ -0,0 +1,103 @@
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
from dishka import make_async_container
|
||||
from dishka.integrations.fastapi import FastapiProvider, setup_dishka
|
||||
from fastapi import FastAPI
|
||||
|
||||
from messenger.identity.config import IdentitySettings
|
||||
from messenger.identity.domain.events import SessionClosed, SessionOpened, UserRegistered
|
||||
from messenger.identity.entrypoints.authentication import challenge_for, guard
|
||||
from messenger.identity.entrypoints.errors import ERROR_CODES as IDENTITY_ERRORS
|
||||
from messenger.identity.entrypoints.http import router as users_router
|
||||
from messenger.identity.entrypoints.http import sessions_router
|
||||
from messenger.identity.entrypoints.ioc import IdentityProvider
|
||||
from messenger.identity.entrypoints.journal import LOG_FIELDS as IDENTITY_FIELDS
|
||||
from messenger.identity.entrypoints.journal import IdentityJournal
|
||||
from messenger.messaging.config import MessagingSettings
|
||||
from messenger.messaging.domain.events import ChatCreated, MessagePosted
|
||||
from messenger.messaging.entrypoints.errors import ERROR_CODES as MESSAGING_ERRORS
|
||||
from messenger.messaging.entrypoints.http import chats_router, messages_router
|
||||
from messenger.messaging.entrypoints.ioc import MessagingProvider
|
||||
from messenger.messaging.entrypoints.journal import LOG_FIELDS as MESSAGING_FIELDS
|
||||
from messenger.messaging.entrypoints.journal import MessagingJournal
|
||||
from messenger.shared.application.messagebus import EventBus
|
||||
from messenger.shared.application.ports import Logger
|
||||
from messenger.shared.config import PlatformSettings
|
||||
from messenger.shared.entrypoints import errors, health
|
||||
from messenger.shared.entrypoints.config import TransportSettings
|
||||
from messenger.shared.entrypoints.ioc import PlatformProvider
|
||||
from messenger.shared.entrypoints.pipeline import RequestPipeline
|
||||
from messenger.shared.infrastructure.logging import PLATFORM_FIELDS, StructlogLogger
|
||||
|
||||
TRANSPORT_FIELDS = frozenset({"dropped_total", "queue", "instance"})
|
||||
|
||||
LOG_FIELDS = PLATFORM_FIELDS | TRANSPORT_FIELDS | IDENTITY_FIELDS | MESSAGING_FIELDS
|
||||
ERROR_CODES = {**IDENTITY_ERRORS, **MESSAGING_ERRORS}
|
||||
|
||||
|
||||
def wire_events(bus: EventBus, logger: Logger) -> None:
|
||||
identity = IdentityJournal(logger)
|
||||
bus.subscribe(UserRegistered, identity.on_user_registered)
|
||||
bus.subscribe(SessionOpened, identity.on_session_opened)
|
||||
bus.subscribe(SessionClosed, identity.on_session_closed)
|
||||
|
||||
messaging = MessagingJournal(logger)
|
||||
bus.subscribe(ChatCreated, messaging.on_chat_created)
|
||||
bus.subscribe(MessagePosted, messaging.on_message_posted)
|
||||
|
||||
|
||||
def create_app(
|
||||
platform: PlatformSettings | None = None,
|
||||
transport: TransportSettings | None = None,
|
||||
identity: IdentitySettings | None = None,
|
||||
messaging: MessagingSettings | None = None,
|
||||
) -> FastAPI:
|
||||
platform = platform or PlatformSettings()
|
||||
transport = transport or TransportSettings()
|
||||
identity = identity or IdentitySettings()
|
||||
messaging = messaging or MessagingSettings()
|
||||
logger = StructlogLogger(level=platform.log_level, allowed_fields=LOG_FIELDS)
|
||||
container = make_async_container(
|
||||
PlatformProvider(platform, logger),
|
||||
IdentityProvider(identity),
|
||||
MessagingProvider(messaging),
|
||||
FastapiProvider(),
|
||||
)
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_app: FastAPI) -> AsyncIterator[None]:
|
||||
bus = await container.get(EventBus)
|
||||
wire_events(bus, logger)
|
||||
bus.start()
|
||||
logger.info("service.started")
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
await bus.stop()
|
||||
await container.close()
|
||||
logger.info("service.stopped")
|
||||
|
||||
app = FastAPI(
|
||||
title="MTUSI Messenger",
|
||||
version="1.2.0",
|
||||
lifespan=lifespan,
|
||||
docs_url="/docs" if transport.docs else None,
|
||||
redoc_url=None,
|
||||
openapi_url="/openapi.json" if transport.docs else None,
|
||||
)
|
||||
app.add_middleware(
|
||||
RequestPipeline,
|
||||
logger=logger,
|
||||
max_bytes=transport.max_body_bytes,
|
||||
timeout=transport.request_timeout_seconds,
|
||||
guard=guard,
|
||||
)
|
||||
errors.install(app, logger, ERROR_CODES, challenge_for)
|
||||
app.include_router(health.router)
|
||||
app.include_router(users_router)
|
||||
app.include_router(sessions_router)
|
||||
app.include_router(chats_router)
|
||||
app.include_router(messages_router)
|
||||
setup_dishka(container, app)
|
||||
return app
|
||||
@@ -0,0 +1,5 @@
|
||||
from messenger.shared.application.messagebus import CommandBus
|
||||
|
||||
|
||||
class MessagingCommandBus(CommandBus):
|
||||
__slots__ = ()
|
||||
@@ -0,0 +1,19 @@
|
||||
from collections.abc import Sequence
|
||||
from dataclasses import dataclass
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.shared.application.commands import Command
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class CreateChat(Command):
|
||||
creator_id: UUID
|
||||
title: str
|
||||
member_ids: Sequence[UUID]
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class PostMessage(Command):
|
||||
sender_id: UUID
|
||||
chat_id: UUID
|
||||
text: str
|
||||
@@ -0,0 +1,51 @@
|
||||
from messenger.messaging.application.commands import CreateChat, PostMessage
|
||||
from messenger.messaging.application.ports import MessagingUnitOfWork
|
||||
from messenger.messaging.domain.errors import ChatNotFound
|
||||
from messenger.messaging.domain.models import Chat, Message
|
||||
from messenger.shared.application.ports import Clock, IdGenerator
|
||||
|
||||
|
||||
class CreateChatHandler:
|
||||
__slots__ = ("_clock", "_ids", "_uow")
|
||||
|
||||
def __init__(self, uow: MessagingUnitOfWork, clock: Clock, ids: IdGenerator) -> None:
|
||||
self._uow = uow
|
||||
self._clock = clock
|
||||
self._ids = ids
|
||||
|
||||
async def __call__(self, command: CreateChat) -> Chat:
|
||||
chat = Chat.create(
|
||||
chat_id=self._ids.new_id(),
|
||||
title=command.title,
|
||||
member_ids=command.member_ids,
|
||||
creator_id=command.creator_id,
|
||||
created_at=self._clock.now(),
|
||||
)
|
||||
async with self._uow.transaction():
|
||||
await self._uow.chats.add(chat)
|
||||
await self._uow.commit()
|
||||
return chat
|
||||
|
||||
|
||||
class PostMessageHandler:
|
||||
__slots__ = ("_clock", "_ids", "_uow")
|
||||
|
||||
def __init__(self, uow: MessagingUnitOfWork, clock: Clock, ids: IdGenerator) -> None:
|
||||
self._uow = uow
|
||||
self._clock = clock
|
||||
self._ids = ids
|
||||
|
||||
async def __call__(self, command: PostMessage) -> Message:
|
||||
async with self._uow.transaction():
|
||||
chat = await self._uow.chats.get(command.chat_id)
|
||||
if chat is None:
|
||||
raise ChatNotFound("чат не найден")
|
||||
message = chat.post(
|
||||
message_id=self._ids.new_id(),
|
||||
sender_id=command.sender_id,
|
||||
text=command.text,
|
||||
now=self._clock.now(),
|
||||
)
|
||||
await self._uow.chats.append(message)
|
||||
await self._uow.commit()
|
||||
return message
|
||||
@@ -0,0 +1,41 @@
|
||||
from typing import Protocol, runtime_checkable
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.messaging.domain.keys import HistoryKey
|
||||
from messenger.messaging.domain.models import Chat, Message
|
||||
from messenger.shared.application.ports import UnitOfWork
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class CursorCodec(Protocol):
|
||||
def encode(self, scope: str, key: HistoryKey) -> str: ...
|
||||
|
||||
def decode(self, scope: str, raw: str) -> HistoryKey: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class ChatRepository(Protocol):
|
||||
async def add(self, chat: Chat) -> None: ...
|
||||
|
||||
async def get(self, chat_id: UUID) -> Chat | None: ...
|
||||
|
||||
async def append(self, message: Message) -> None: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class MessagingUnitOfWork(UnitOfWork, Protocol):
|
||||
@property
|
||||
def chats(self) -> ChatRepository: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class ChatDirectory(Protocol):
|
||||
async def chat_for_member(self, chat_id: UUID, user_id: UUID) -> Chat | None: ...
|
||||
|
||||
async def chats_of(
|
||||
self, user_id: UUID, *, after: HistoryKey | None, limit: int
|
||||
) -> tuple[list[Chat], bool]: ...
|
||||
|
||||
async def history(
|
||||
self, chat_id: UUID, *, after: HistoryKey | None, limit: int
|
||||
) -> tuple[list[Message], bool]: ...
|
||||
@@ -0,0 +1,73 @@
|
||||
from dataclasses import dataclass
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.messaging.application.ports import ChatDirectory, CursorCodec
|
||||
from messenger.messaging.domain.errors import ChatNotFound
|
||||
from messenger.messaging.domain.keys import HistoryKey
|
||||
from messenger.messaging.domain.models import Chat, Message
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Page[ItemT]:
|
||||
items: list[ItemT]
|
||||
next_cursor: str | None
|
||||
|
||||
|
||||
def chats_scope(user_id: UUID) -> str:
|
||||
return f"chats:{user_id}"
|
||||
|
||||
|
||||
def messages_scope(chat_id: UUID) -> str:
|
||||
return f"messages:{chat_id}"
|
||||
|
||||
|
||||
class GetChat:
|
||||
__slots__ = ("_chats",)
|
||||
|
||||
def __init__(self, chats: ChatDirectory) -> None:
|
||||
self._chats = chats
|
||||
|
||||
async def __call__(self, chat_id: UUID, user_id: UUID) -> Chat:
|
||||
chat = await self._chats.chat_for_member(chat_id, user_id)
|
||||
if chat is None:
|
||||
raise ChatNotFound("чат не найден")
|
||||
return chat
|
||||
|
||||
|
||||
class ListChats:
|
||||
__slots__ = ("_chats", "_cursors")
|
||||
|
||||
def __init__(self, chats: ChatDirectory, cursors: CursorCodec) -> None:
|
||||
self._chats = chats
|
||||
self._cursors = cursors
|
||||
|
||||
async def __call__(self, user_id: UUID, *, limit: int, cursor: str | None) -> Page[Chat]:
|
||||
scope = chats_scope(user_id)
|
||||
after: HistoryKey | None = self._cursors.decode(scope, cursor) if cursor else None
|
||||
items, has_more = await self._chats.chats_of(user_id, after=after, limit=limit)
|
||||
next_cursor = self._cursors.encode(scope, items[-1].key) if has_more and items else None
|
||||
return Page(items=items, next_cursor=next_cursor)
|
||||
|
||||
|
||||
class ReadHistory:
|
||||
__slots__ = ("_chats", "_cursors")
|
||||
|
||||
def __init__(self, chats: ChatDirectory, cursors: CursorCodec) -> None:
|
||||
self._chats = chats
|
||||
self._cursors = cursors
|
||||
|
||||
async def __call__(
|
||||
self,
|
||||
chat_id: UUID,
|
||||
user_id: UUID,
|
||||
*,
|
||||
limit: int,
|
||||
cursor: str | None,
|
||||
) -> Page[Message]:
|
||||
if await self._chats.chat_for_member(chat_id, user_id) is None:
|
||||
raise ChatNotFound("чат не найден")
|
||||
scope = messages_scope(chat_id)
|
||||
after: HistoryKey | None = self._cursors.decode(scope, cursor) if cursor else None
|
||||
items, has_more = await self._chats.history(chat_id, after=after, limit=limit)
|
||||
next_cursor = self._cursors.encode(scope, items[-1].key) if has_more and items else None
|
||||
return Page(items=items, next_cursor=next_cursor)
|
||||
@@ -0,0 +1,7 @@
|
||||
from pydantic import Field, SecretStr
|
||||
|
||||
from messenger.shared.config import Settings
|
||||
|
||||
|
||||
class MessagingSettings(Settings):
|
||||
cursor_secret: SecretStr = Field(min_length=16)
|
||||
@@ -0,0 +1,21 @@
|
||||
from messenger.shared.domain.errors import DomainError
|
||||
|
||||
|
||||
class MessagingError(DomainError):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidChatData(MessagingError):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidMessageText(MessagingError):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidPageRequest(MessagingError):
|
||||
pass
|
||||
|
||||
|
||||
class ChatNotFound(MessagingError):
|
||||
pass
|
||||
@@ -0,0 +1,24 @@
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.shared.domain.events import DomainEvent
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ChatCreated(DomainEvent):
|
||||
chat_id: UUID
|
||||
creator_id: UUID
|
||||
member_count: int
|
||||
created_at: datetime
|
||||
name: str = field(init=False, default="chat.created")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class MessagePosted(DomainEvent):
|
||||
message_id: UUID
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text_length: int
|
||||
created_at: datetime
|
||||
name: str = field(init=False, default="message.posted")
|
||||
@@ -0,0 +1,3 @@
|
||||
from datetime import datetime
|
||||
|
||||
type HistoryKey = tuple[datetime, int]
|
||||
@@ -0,0 +1,130 @@
|
||||
from collections.abc import Sequence
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.messaging.domain.errors import ChatNotFound, InvalidChatData
|
||||
from messenger.messaging.domain.events import ChatCreated, MessagePosted
|
||||
from messenger.messaging.domain.keys import HistoryKey
|
||||
from messenger.messaging.domain.values import CHAT_MEMBERS_MAX, ChatTitle, MessageText
|
||||
from messenger.shared.domain.events import DomainEvent
|
||||
|
||||
TICK = timedelta(microseconds=1)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Message:
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text: MessageText
|
||||
created_at: datetime
|
||||
|
||||
@property
|
||||
def key(self) -> HistoryKey:
|
||||
return (self.created_at, self.id.int)
|
||||
|
||||
|
||||
class Chat:
|
||||
__slots__ = (
|
||||
"_events",
|
||||
"_members",
|
||||
"created_at",
|
||||
"id",
|
||||
"last_message_at",
|
||||
"member_ids",
|
||||
"title",
|
||||
)
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
chat_id: UUID,
|
||||
title: ChatTitle,
|
||||
member_ids: Sequence[UUID],
|
||||
created_at: datetime,
|
||||
last_message_at: datetime | None = None,
|
||||
) -> None:
|
||||
self.id = chat_id
|
||||
self.title = title
|
||||
self.member_ids: tuple[UUID, ...] = tuple(member_ids)
|
||||
self.created_at = created_at
|
||||
self.last_message_at = last_message_at
|
||||
self._members: frozenset[UUID] = frozenset(member_ids)
|
||||
self._events: list[DomainEvent] = []
|
||||
|
||||
@classmethod
|
||||
def create(
|
||||
cls,
|
||||
*,
|
||||
chat_id: UUID,
|
||||
title: str,
|
||||
member_ids: Sequence[UUID],
|
||||
creator_id: UUID,
|
||||
created_at: datetime,
|
||||
) -> Chat:
|
||||
if not member_ids:
|
||||
raise InvalidChatData("поле member_ids не может быть пустым")
|
||||
if len(member_ids) > CHAT_MEMBERS_MAX:
|
||||
raise InvalidChatData(f"поле member_ids содержит больше {CHAT_MEMBERS_MAX} участников")
|
||||
unique = set(member_ids)
|
||||
if len(unique) != len(member_ids):
|
||||
raise InvalidChatData("поле member_ids содержит дубликаты")
|
||||
if creator_id not in unique:
|
||||
raise InvalidChatData("создатель чата обязан входить в список member_ids")
|
||||
chat = cls(
|
||||
chat_id=chat_id,
|
||||
title=ChatTitle(title),
|
||||
member_ids=member_ids,
|
||||
created_at=created_at,
|
||||
)
|
||||
chat.record(
|
||||
ChatCreated(
|
||||
chat_id=chat.id,
|
||||
creator_id=creator_id,
|
||||
member_count=len(unique),
|
||||
created_at=created_at,
|
||||
)
|
||||
)
|
||||
return chat
|
||||
|
||||
@property
|
||||
def key(self) -> HistoryKey:
|
||||
return (self.created_at, self.id.int)
|
||||
|
||||
def record(self, event: DomainEvent) -> None:
|
||||
self._events.append(event)
|
||||
|
||||
def is_member(self, user_id: UUID) -> bool:
|
||||
return user_id in self._members
|
||||
|
||||
def require_member(self, user_id: UUID) -> None:
|
||||
if not self.is_member(user_id):
|
||||
raise ChatNotFound("чат не найден")
|
||||
|
||||
def post(self, *, message_id: UUID, sender_id: UUID, text: str, now: datetime) -> Message:
|
||||
self.require_member(sender_id)
|
||||
last = self.last_message_at
|
||||
created_at = now if last is None or now > last else last + TICK
|
||||
message = Message(
|
||||
id=message_id,
|
||||
chat_id=self.id,
|
||||
sender_id=sender_id,
|
||||
text=MessageText(text),
|
||||
created_at=created_at,
|
||||
)
|
||||
self.last_message_at = created_at
|
||||
self.record(
|
||||
MessagePosted(
|
||||
message_id=message.id,
|
||||
chat_id=self.id,
|
||||
sender_id=sender_id,
|
||||
text_length=len(message.text.value),
|
||||
created_at=created_at,
|
||||
)
|
||||
)
|
||||
return message
|
||||
|
||||
def collect_events(self) -> list[DomainEvent]:
|
||||
events, self._events = self._events, []
|
||||
return events
|
||||
@@ -0,0 +1,39 @@
|
||||
from dataclasses import dataclass
|
||||
|
||||
from messenger.messaging.domain.errors import InvalidChatData, InvalidMessageText
|
||||
|
||||
CHAT_TITLE_MAX = 100
|
||||
MESSAGE_TEXT_MAX = 4000
|
||||
CHAT_MEMBERS_MAX = 100
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ChatTitle:
|
||||
value: str
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not isinstance(self.value, str):
|
||||
raise InvalidChatData("поле title должно быть строкой")
|
||||
if not self.value.strip():
|
||||
raise InvalidChatData("поле title не может быть пустым или состоять из пробелов")
|
||||
if len(self.value) > CHAT_TITLE_MAX:
|
||||
raise InvalidChatData(f"поле title длиннее {CHAT_TITLE_MAX} символов Unicode")
|
||||
|
||||
def __str__(self) -> str:
|
||||
return self.value
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class MessageText:
|
||||
value: str
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not isinstance(self.value, str):
|
||||
raise InvalidMessageText("поле text должно быть строкой")
|
||||
if not self.value.strip():
|
||||
raise InvalidMessageText("поле text не может быть пустым или состоять из пробелов")
|
||||
if len(self.value) > MESSAGE_TEXT_MAX:
|
||||
raise InvalidMessageText(f"поле text длиннее {MESSAGE_TEXT_MAX} символов Unicode")
|
||||
|
||||
def __str__(self) -> str:
|
||||
return self.value
|
||||
@@ -0,0 +1,14 @@
|
||||
from messenger.messaging.domain.errors import (
|
||||
ChatNotFound,
|
||||
InvalidChatData,
|
||||
InvalidMessageText,
|
||||
InvalidPageRequest,
|
||||
)
|
||||
from messenger.shared.domain.errors import DomainError
|
||||
|
||||
ERROR_CODES: dict[type[DomainError], tuple[str, int]] = {
|
||||
InvalidChatData: ("invalid_request", 400),
|
||||
InvalidMessageText: ("invalid_request", 400),
|
||||
InvalidPageRequest: ("invalid_request", 400),
|
||||
ChatNotFound: ("not_found", 404),
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from dishka.integrations.fastapi import FromDishka, inject
|
||||
from fastapi import APIRouter, Query, status
|
||||
|
||||
from messenger.messaging.application.bus import MessagingCommandBus
|
||||
from messenger.messaging.application.commands import CreateChat, PostMessage
|
||||
from messenger.messaging.application.queries import GetChat, ListChats, ReadHistory
|
||||
from messenger.messaging.entrypoints.schemas import (
|
||||
ChatOut,
|
||||
CreateChatRequest,
|
||||
CreateMessageRequest,
|
||||
MessageOut,
|
||||
PageOut,
|
||||
PageQuery,
|
||||
)
|
||||
from messenger.shared.entrypoints.actor import Actor
|
||||
|
||||
chats_router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
|
||||
messages_router = APIRouter(prefix="/api/v1/chats/{chat_id}/messages", tags=["messages"])
|
||||
|
||||
|
||||
@chats_router.post("", status_code=status.HTTP_201_CREATED)
|
||||
@inject
|
||||
async def create_chat(
|
||||
actor: Actor,
|
||||
body: CreateChatRequest,
|
||||
bus: FromDishka[MessagingCommandBus],
|
||||
) -> ChatOut:
|
||||
chat = await bus.execute(
|
||||
CreateChat(creator_id=actor, title=body.title, member_ids=body.member_ids)
|
||||
)
|
||||
return ChatOut.of(chat)
|
||||
|
||||
|
||||
@chats_router.get("")
|
||||
@inject
|
||||
async def list_chats(
|
||||
actor: Actor,
|
||||
page: Annotated[PageQuery, Query()],
|
||||
query: FromDishka[ListChats],
|
||||
) -> PageOut[ChatOut]:
|
||||
chats = await query(actor, limit=page.limit, cursor=page.cursor)
|
||||
return PageOut[ChatOut].of(chats, ChatOut.of)
|
||||
|
||||
|
||||
@chats_router.get("/{chat_id}")
|
||||
@inject
|
||||
async def read_chat(
|
||||
chat_id: UUID,
|
||||
actor: Actor,
|
||||
query: FromDishka[GetChat],
|
||||
) -> ChatOut:
|
||||
return ChatOut.of(await query(chat_id, actor))
|
||||
|
||||
|
||||
@messages_router.post("", status_code=status.HTTP_201_CREATED)
|
||||
@inject
|
||||
async def post_message(
|
||||
chat_id: UUID,
|
||||
actor: Actor,
|
||||
body: CreateMessageRequest,
|
||||
bus: FromDishka[MessagingCommandBus],
|
||||
) -> MessageOut:
|
||||
message = await bus.execute(PostMessage(sender_id=actor, chat_id=chat_id, text=body.text))
|
||||
return MessageOut.of(message)
|
||||
|
||||
|
||||
@messages_router.get("")
|
||||
@inject
|
||||
async def read_history(
|
||||
chat_id: UUID,
|
||||
actor: Actor,
|
||||
page: Annotated[PageQuery, Query()],
|
||||
query: FromDishka[ReadHistory],
|
||||
) -> PageOut[MessageOut]:
|
||||
messages = await query(chat_id, actor, limit=page.limit, cursor=page.cursor)
|
||||
return PageOut[MessageOut].of(messages, MessageOut.of)
|
||||
@@ -0,0 +1,65 @@
|
||||
from dishka import Provider, Scope, provide
|
||||
|
||||
from messenger.messaging.application.bus import MessagingCommandBus
|
||||
from messenger.messaging.application.commands import CreateChat, PostMessage
|
||||
from messenger.messaging.application.handlers import CreateChatHandler, PostMessageHandler
|
||||
from messenger.messaging.application.ports import ChatDirectory, CursorCodec, MessagingUnitOfWork
|
||||
from messenger.messaging.application.queries import GetChat, ListChats, ReadHistory
|
||||
from messenger.messaging.config import MessagingSettings
|
||||
from messenger.messaging.infrastructure.cursor import SignedCursorCodec
|
||||
from messenger.messaging.infrastructure.postgres import (
|
||||
PostgresChatDirectory,
|
||||
PostgresMessagingUnitOfWork,
|
||||
)
|
||||
from messenger.shared.application.commands import Command
|
||||
from messenger.shared.application.messagebus import CommandHandler
|
||||
from messenger.shared.application.ports import Clock, EventPublisher, IdGenerator
|
||||
from messenger.shared.infrastructure.postgres import Database
|
||||
|
||||
|
||||
class MessagingProvider(Provider):
|
||||
def __init__(self, settings: MessagingSettings) -> None:
|
||||
super().__init__()
|
||||
self._settings = settings
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def settings(self) -> MessagingSettings:
|
||||
return self._settings
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def directory(self, database: Database) -> ChatDirectory:
|
||||
return PostgresChatDirectory(database)
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def cursors(self, settings: MessagingSettings) -> CursorCodec:
|
||||
return SignedCursorCodec(settings.cursor_secret.get_secret_value().encode())
|
||||
|
||||
@provide(scope=Scope.REQUEST)
|
||||
def unit_of_work(self, database: Database) -> MessagingUnitOfWork:
|
||||
return PostgresMessagingUnitOfWork(database)
|
||||
|
||||
@provide(scope=Scope.REQUEST)
|
||||
def chat(self, directory: ChatDirectory) -> GetChat:
|
||||
return GetChat(directory)
|
||||
|
||||
@provide(scope=Scope.REQUEST)
|
||||
def chat_list(self, directory: ChatDirectory, cursors: CursorCodec) -> ListChats:
|
||||
return ListChats(directory, cursors)
|
||||
|
||||
@provide(scope=Scope.REQUEST)
|
||||
def history(self, directory: ChatDirectory, cursors: CursorCodec) -> ReadHistory:
|
||||
return ReadHistory(directory, cursors)
|
||||
|
||||
@provide(scope=Scope.REQUEST)
|
||||
def command_bus(
|
||||
self,
|
||||
uow: MessagingUnitOfWork,
|
||||
publisher: EventPublisher,
|
||||
clock: Clock,
|
||||
ids: IdGenerator,
|
||||
) -> MessagingCommandBus:
|
||||
handlers: dict[type[Command], CommandHandler] = {
|
||||
CreateChat: CreateChatHandler(uow, clock, ids),
|
||||
PostMessage: PostMessageHandler(uow, clock, ids),
|
||||
}
|
||||
return MessagingCommandBus(handlers, uow, publisher)
|
||||
@@ -0,0 +1,27 @@
|
||||
from messenger.messaging.domain.events import ChatCreated, MessagePosted
|
||||
from messenger.shared.application.ports import Logger
|
||||
|
||||
LOG_FIELDS = frozenset({"chat_id", "message_id", "count"})
|
||||
|
||||
|
||||
class MessagingJournal:
|
||||
__slots__ = ("_logger",)
|
||||
|
||||
def __init__(self, logger: Logger) -> None:
|
||||
self._logger = logger
|
||||
|
||||
async def on_chat_created(self, event: ChatCreated) -> None:
|
||||
self._logger.info(
|
||||
"audit.chat_created",
|
||||
chat_id=str(event.chat_id),
|
||||
actor_id=str(event.creator_id),
|
||||
count=event.member_count,
|
||||
)
|
||||
|
||||
async def on_message_posted(self, event: MessagePosted) -> None:
|
||||
self._logger.info(
|
||||
"audit.message_posted",
|
||||
chat_id=str(event.chat_id),
|
||||
actor_id=str(event.sender_id),
|
||||
message_id=str(event.message_id),
|
||||
)
|
||||
@@ -0,0 +1,72 @@
|
||||
from collections.abc import Callable
|
||||
from datetime import datetime
|
||||
from typing import Annotated, Self
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
|
||||
from messenger.messaging.application.queries import Page
|
||||
from messenger.messaging.domain.models import Chat, Message
|
||||
|
||||
STRICT = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
|
||||
class CreateChatRequest(BaseModel):
|
||||
model_config = STRICT
|
||||
|
||||
title: str
|
||||
member_ids: list[Annotated[UUID, Field(strict=False)]]
|
||||
|
||||
|
||||
class CreateMessageRequest(BaseModel):
|
||||
model_config = STRICT
|
||||
|
||||
text: str
|
||||
|
||||
|
||||
class PageQuery(BaseModel):
|
||||
limit: int = Field(default=50, ge=1, le=100)
|
||||
cursor: str | None = None
|
||||
|
||||
|
||||
class ChatOut(BaseModel):
|
||||
id: UUID
|
||||
title: str
|
||||
member_ids: tuple[UUID, ...]
|
||||
created_at: datetime
|
||||
|
||||
@classmethod
|
||||
def of(cls, chat: Chat) -> ChatOut:
|
||||
return cls(
|
||||
id=chat.id,
|
||||
title=chat.title.value,
|
||||
member_ids=chat.member_ids,
|
||||
created_at=chat.created_at,
|
||||
)
|
||||
|
||||
|
||||
class MessageOut(BaseModel):
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text: str
|
||||
created_at: datetime
|
||||
|
||||
@classmethod
|
||||
def of(cls, message: Message) -> MessageOut:
|
||||
return cls(
|
||||
id=message.id,
|
||||
chat_id=message.chat_id,
|
||||
sender_id=message.sender_id,
|
||||
text=message.text.value,
|
||||
created_at=message.created_at,
|
||||
)
|
||||
|
||||
|
||||
class PageOut[ItemT](BaseModel):
|
||||
items: list[ItemT]
|
||||
next_cursor: str | None
|
||||
|
||||
@classmethod
|
||||
def of[SourceT](cls, page: Page[SourceT], view: Callable[[SourceT], ItemT]) -> Self:
|
||||
return cls(items=[view(item) for item in page.items], next_cursor=page.next_cursor)
|
||||
@@ -0,0 +1,59 @@
|
||||
import hmac
|
||||
from base64 import urlsafe_b64decode, urlsafe_b64encode
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from hashlib import sha256
|
||||
|
||||
from messenger.messaging.domain.errors import InvalidPageRequest
|
||||
from messenger.messaging.domain.keys import HistoryKey
|
||||
|
||||
VERSION = "1"
|
||||
SIGNATURE_BYTES = 12
|
||||
EPOCH = datetime(1970, 1, 1, tzinfo=UTC)
|
||||
PARTS = 4
|
||||
|
||||
|
||||
def _encode_part(value: bytes) -> str:
|
||||
return urlsafe_b64encode(value).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def _decode_part(value: str) -> bytes:
|
||||
padding = "=" * (-len(value) % 4)
|
||||
try:
|
||||
return urlsafe_b64decode(value + padding)
|
||||
except (ValueError, TypeError) as error:
|
||||
raise InvalidPageRequest("параметр cursor повреждён") from error
|
||||
|
||||
|
||||
class SignedCursorCodec:
|
||||
__slots__ = ("_secret",)
|
||||
|
||||
def __init__(self, secret: bytes) -> None:
|
||||
self._secret = secret
|
||||
|
||||
def encode(self, scope: str, key: HistoryKey) -> str:
|
||||
moment, identifier = key
|
||||
micros = (moment - EPOCH) // timedelta(microseconds=1)
|
||||
body = f"{VERSION}.{micros}.{identifier:032x}"
|
||||
return f"{body}.{_encode_part(self._sign(scope, body))}"
|
||||
|
||||
def decode(self, scope: str, raw: str) -> HistoryKey:
|
||||
parts = raw.split(".")
|
||||
if len(parts) != PARTS or parts[0] != VERSION:
|
||||
raise InvalidPageRequest("параметр cursor не распознан")
|
||||
body = ".".join(parts[:3])
|
||||
if not hmac.compare_digest(self._sign(scope, body), _decode_part(parts[3])):
|
||||
raise InvalidPageRequest("параметр cursor недействителен для этого запроса")
|
||||
try:
|
||||
micros = int(parts[1])
|
||||
identifier = int(parts[2], 16)
|
||||
except ValueError as error:
|
||||
raise InvalidPageRequest("параметр cursor повреждён") from error
|
||||
try:
|
||||
moment = EPOCH + timedelta(microseconds=micros)
|
||||
except (OverflowError, ValueError) as error:
|
||||
raise InvalidPageRequest("параметр cursor повреждён") from error
|
||||
return (moment, identifier)
|
||||
|
||||
def _sign(self, scope: str, body: str) -> bytes:
|
||||
payload = f"{scope}|{body}".encode()
|
||||
return hmac.new(self._secret, payload, sha256).digest()[:SIGNATURE_BYTES]
|
||||
@@ -0,0 +1,179 @@
|
||||
from collections.abc import Sequence
|
||||
from uuid import UUID
|
||||
|
||||
from asyncpg import ForeignKeyViolationError, Record
|
||||
|
||||
from messenger.messaging.domain.errors import InvalidChatData
|
||||
from messenger.messaging.domain.keys import HistoryKey
|
||||
from messenger.messaging.domain.models import Chat, Message
|
||||
from messenger.messaging.domain.values import ChatTitle, MessageText
|
||||
from messenger.shared.infrastructure.postgres import (
|
||||
Connection,
|
||||
Database,
|
||||
EventSource,
|
||||
PostgresUnitOfWork,
|
||||
)
|
||||
|
||||
INSERT_CHAT = "INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)"
|
||||
INSERT_MEMBERS = """
|
||||
INSERT INTO chat_members (chat_id, user_id, position, chat_created_at)
|
||||
SELECT $1, member.user_id, member.position, $3
|
||||
FROM unnest($2::uuid[]) WITH ORDINALITY AS member (user_id, position)
|
||||
"""
|
||||
LOCK_CHAT = """
|
||||
SELECT c.id, c.title, c.created_at, c.last_message_at,
|
||||
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY position) AS member_ids
|
||||
FROM chats c
|
||||
WHERE c.id = $1
|
||||
FOR UPDATE
|
||||
"""
|
||||
APPEND_MESSAGE = """
|
||||
WITH message AS (
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
RETURNING chat_id, created_at
|
||||
)
|
||||
UPDATE chats SET last_message_at = message.created_at
|
||||
FROM message
|
||||
WHERE chats.id = message.chat_id
|
||||
"""
|
||||
CHAT_OF_MEMBER = """
|
||||
SELECT c.id, c.title, c.created_at,
|
||||
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY position) AS member_ids
|
||||
FROM chat_members m JOIN chats c ON c.id = m.chat_id
|
||||
WHERE m.chat_id = $1 AND m.user_id = $2
|
||||
"""
|
||||
CHATS_FIRST = """
|
||||
SELECT c.id, c.title, c.created_at,
|
||||
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY position) AS member_ids
|
||||
FROM chat_members m JOIN chats c ON c.id = m.chat_id
|
||||
WHERE m.user_id = $1
|
||||
ORDER BY m.chat_created_at, m.chat_id
|
||||
LIMIT $2
|
||||
"""
|
||||
CHATS_AFTER = """
|
||||
SELECT c.id, c.title, c.created_at,
|
||||
ARRAY(SELECT user_id FROM chat_members WHERE chat_id = c.id ORDER BY position) AS member_ids
|
||||
FROM chat_members m JOIN chats c ON c.id = m.chat_id
|
||||
WHERE m.user_id = $1 AND (m.chat_created_at, m.chat_id) > ($2, $3)
|
||||
ORDER BY m.chat_created_at, m.chat_id
|
||||
LIMIT $4
|
||||
"""
|
||||
HISTORY_FIRST = """
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
LIMIT $2
|
||||
"""
|
||||
HISTORY_AFTER = """
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
LIMIT $4
|
||||
"""
|
||||
|
||||
|
||||
def chat_of(row: Record) -> Chat:
|
||||
return Chat(
|
||||
chat_id=row["id"],
|
||||
title=ChatTitle(row["title"]),
|
||||
member_ids=row["member_ids"],
|
||||
created_at=row["created_at"],
|
||||
last_message_at=row.get("last_message_at"),
|
||||
)
|
||||
|
||||
|
||||
def message_of(row: Record) -> Message:
|
||||
return Message(
|
||||
id=row["id"],
|
||||
chat_id=row["chat_id"],
|
||||
sender_id=row["sender_id"],
|
||||
text=MessageText(row["text"]),
|
||||
created_at=row["created_at"],
|
||||
)
|
||||
|
||||
|
||||
def page[ItemT](rows: Sequence[ItemT], limit: int) -> tuple[list[ItemT], bool]:
|
||||
return list(rows[:limit]), len(rows) > limit
|
||||
|
||||
|
||||
class PostgresChatRepository:
|
||||
__slots__ = ("_connection", "_seen")
|
||||
|
||||
def __init__(self, connection: Connection, seen: list[EventSource]) -> None:
|
||||
self._connection = connection
|
||||
self._seen = seen
|
||||
|
||||
async def add(self, chat: Chat) -> None:
|
||||
await self._connection.execute(INSERT_CHAT, chat.id, chat.title.value, chat.created_at)
|
||||
try:
|
||||
await self._connection.execute(
|
||||
INSERT_MEMBERS, chat.id, list(chat.member_ids), chat.created_at
|
||||
)
|
||||
except ForeignKeyViolationError as error:
|
||||
raise InvalidChatData("поле member_ids содержит неизвестного пользователя") from error
|
||||
self._seen.append(chat)
|
||||
|
||||
async def get(self, chat_id: UUID) -> Chat | None:
|
||||
row = await self._connection.fetchrow(LOCK_CHAT, chat_id)
|
||||
if row is None:
|
||||
return None
|
||||
chat = chat_of(row)
|
||||
self._seen.append(chat)
|
||||
return chat
|
||||
|
||||
async def append(self, message: Message) -> None:
|
||||
await self._connection.execute(
|
||||
APPEND_MESSAGE,
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text.value,
|
||||
message.created_at,
|
||||
)
|
||||
|
||||
|
||||
class PostgresMessagingUnitOfWork(PostgresUnitOfWork):
|
||||
__slots__ = ()
|
||||
|
||||
@property
|
||||
def chats(self) -> PostgresChatRepository:
|
||||
return PostgresChatRepository(self.connection, self.seen)
|
||||
|
||||
|
||||
class PostgresChatDirectory:
|
||||
__slots__ = ("_database",)
|
||||
|
||||
def __init__(self, database: Database) -> None:
|
||||
self._database = database
|
||||
|
||||
async def chat_for_member(self, chat_id: UUID, user_id: UUID) -> Chat | None:
|
||||
async with self._database.connection() as connection:
|
||||
row = await connection.fetchrow(CHAT_OF_MEMBER, chat_id, user_id)
|
||||
return None if row is None else chat_of(row)
|
||||
|
||||
async def chats_of(
|
||||
self, user_id: UUID, *, after: HistoryKey | None, limit: int
|
||||
) -> tuple[list[Chat], bool]:
|
||||
async with self._database.connection() as connection:
|
||||
if after is None:
|
||||
rows = await connection.fetch(CHATS_FIRST, user_id, limit + 1)
|
||||
else:
|
||||
rows = await connection.fetch(
|
||||
CHATS_AFTER, user_id, after[0], UUID(int=after[1]), limit + 1
|
||||
)
|
||||
return page([chat_of(row) for row in rows], limit)
|
||||
|
||||
async def history(
|
||||
self, chat_id: UUID, *, after: HistoryKey | None, limit: int
|
||||
) -> tuple[list[Message], bool]:
|
||||
async with self._database.connection() as connection:
|
||||
if after is None:
|
||||
rows = await connection.fetch(HISTORY_FIRST, chat_id, limit + 1)
|
||||
else:
|
||||
rows = await connection.fetch(
|
||||
HISTORY_AFTER, chat_id, after[0], UUID(int=after[1]), limit + 1
|
||||
)
|
||||
return page([message_of(row) for row in rows], limit)
|
||||
@@ -0,0 +1,70 @@
|
||||
import asyncio
|
||||
import hashlib
|
||||
from importlib import resources
|
||||
|
||||
import asyncpg
|
||||
|
||||
from messenger.shared.config import PlatformSettings
|
||||
from messenger.shared.infrastructure.logging import PLATFORM_FIELDS, StructlogLogger
|
||||
|
||||
LOCK_KEY = 20_260_002
|
||||
JOURNAL = """
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
checksum text NOT NULL,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
)
|
||||
"""
|
||||
|
||||
|
||||
class MigrationChangedError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def migrations() -> list[tuple[str, str]]:
|
||||
folder = resources.files("messenger") / "migrations"
|
||||
found = (item for item in folder.iterdir() if item.name.endswith(".sql"))
|
||||
return sorted((item.name.removesuffix(".sql"), item.read_text()) for item in found)
|
||||
|
||||
|
||||
async def migrate(dsn: str) -> list[str]:
|
||||
connection = await asyncpg.connect(dsn, timeout=10)
|
||||
try:
|
||||
await connection.execute("SELECT pg_advisory_lock($1)", LOCK_KEY)
|
||||
await connection.execute(JOURNAL)
|
||||
applied = dict(await connection.fetch("SELECT version, checksum FROM schema_migrations"))
|
||||
done: list[str] = []
|
||||
for version, sql in migrations():
|
||||
checksum = hashlib.sha256(sql.encode()).hexdigest()
|
||||
if version in applied:
|
||||
if applied[version] != checksum:
|
||||
raise MigrationChangedError(version)
|
||||
continue
|
||||
async with connection.transaction():
|
||||
await connection.execute(sql)
|
||||
await connection.execute(
|
||||
"INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)",
|
||||
version,
|
||||
checksum,
|
||||
)
|
||||
done.append(version)
|
||||
return done
|
||||
finally:
|
||||
await connection.close()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
settings = PlatformSettings()
|
||||
logger = StructlogLogger(level=settings.log_level, allowed_fields=PLATFORM_FIELDS | {"version"})
|
||||
try:
|
||||
done = asyncio.run(migrate(settings.database_url.get_secret_value()))
|
||||
except MigrationChangedError as error:
|
||||
logger.error("migration.changed", version=str(error))
|
||||
raise SystemExit(1) from None
|
||||
for version in done:
|
||||
logger.info("migration.applied", version=version)
|
||||
logger.info("migration.completed", reason="up to date" if not done else "applied")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,46 @@
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL CONSTRAINT users_username_key UNIQUE
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
|
||||
password_hash text NOT NULL CHECK (password_hash LIKE '$argon2id$%'),
|
||||
created_at timestamptz NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
|
||||
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
|
||||
created_at timestamptz NOT NULL,
|
||||
expires_at timestamptz NOT NULL,
|
||||
CHECK (expires_at > created_at)
|
||||
);
|
||||
|
||||
CREATE INDEX sessions_user_idx ON sessions (user_id);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL,
|
||||
last_message_at timestamptz
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
position smallint NOT NULL CHECK (position BETWEEN 1 AND 100),
|
||||
chat_created_at timestamptz NOT NULL,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_created_at, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL,
|
||||
sender_id uuid NOT NULL,
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
created_at timestamptz NOT NULL,
|
||||
FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,2 @@
|
||||
class Command:
|
||||
pass
|
||||
@@ -0,0 +1,2 @@
|
||||
class Unavailable(Exception):
|
||||
pass
|
||||
@@ -0,0 +1,123 @@
|
||||
import asyncio
|
||||
from collections.abc import Awaitable, Callable, Mapping, Sequence
|
||||
from contextlib import suppress
|
||||
from typing import Any
|
||||
|
||||
from messenger.shared.application.commands import Command
|
||||
from messenger.shared.application.ports import EventPublisher, Logger, UnitOfWork
|
||||
from messenger.shared.domain.events import DomainEvent
|
||||
|
||||
type CommandHandler = Callable[[Any], Awaitable[Any]]
|
||||
type EventHandler[EventT: DomainEvent] = Callable[[EventT], Awaitable[None]]
|
||||
|
||||
|
||||
class CommandBus:
|
||||
__slots__ = ("_handlers", "_publisher", "_uow")
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
handlers: Mapping[type[Command], CommandHandler],
|
||||
uow: UnitOfWork,
|
||||
publisher: EventPublisher,
|
||||
) -> None:
|
||||
self._handlers = handlers
|
||||
self._uow = uow
|
||||
self._publisher = publisher
|
||||
|
||||
async def execute(self, command: Command) -> Any:
|
||||
handler = self._handlers.get(type(command))
|
||||
if handler is None:
|
||||
raise LookupError(f"нет обработчика для команды {type(command).__name__}")
|
||||
result = await handler(command)
|
||||
events = self._uow.collect_new_events()
|
||||
if events:
|
||||
await self._publisher.publish(events)
|
||||
return result
|
||||
|
||||
|
||||
class EventBus:
|
||||
__slots__ = ("_deferred", "_dropped", "_logger", "_projections", "_queue", "_worker")
|
||||
|
||||
def __init__(self, logger: Logger, *, max_queue: int = 10_000) -> None:
|
||||
self._logger = logger
|
||||
self._queue: asyncio.Queue[DomainEvent] = asyncio.Queue(maxsize=max_queue)
|
||||
self._projections: dict[type[DomainEvent], list[Any]] = {}
|
||||
self._deferred: dict[type[DomainEvent], list[Any]] = {}
|
||||
self._worker: asyncio.Task[None] | None = None
|
||||
self._dropped = 0
|
||||
|
||||
def project[EventT: DomainEvent](
|
||||
self, event_type: type[EventT], handler: EventHandler[EventT]
|
||||
) -> None:
|
||||
self._projections.setdefault(event_type, []).append(handler)
|
||||
|
||||
def subscribe[EventT: DomainEvent](
|
||||
self, event_type: type[EventT], handler: EventHandler[EventT]
|
||||
) -> None:
|
||||
self._deferred.setdefault(event_type, []).append(handler)
|
||||
|
||||
async def emit(self, event: DomainEvent) -> bool:
|
||||
await self._run(self._projections.get(type(event), []), event, "projection")
|
||||
if not self._deferred.get(type(event)):
|
||||
return True
|
||||
try:
|
||||
self._queue.put_nowait(event)
|
||||
except asyncio.QueueFull:
|
||||
self._dropped += 1
|
||||
self._logger.warning(
|
||||
"event.dropped", event_name=event.name, dropped_total=self._dropped
|
||||
)
|
||||
return False
|
||||
return True
|
||||
|
||||
@property
|
||||
def dropped(self) -> int:
|
||||
return self._dropped
|
||||
|
||||
@property
|
||||
def pending(self) -> int:
|
||||
return self._queue.qsize()
|
||||
|
||||
def start(self) -> None:
|
||||
if self._worker is None:
|
||||
self._worker = asyncio.create_task(self._drain())
|
||||
|
||||
async def stop(self) -> None:
|
||||
if self._worker is None:
|
||||
return
|
||||
await self._queue.join()
|
||||
self._worker.cancel()
|
||||
with suppress(asyncio.CancelledError):
|
||||
await self._worker
|
||||
self._worker = None
|
||||
|
||||
async def _drain(self) -> None:
|
||||
while True:
|
||||
event = await self._queue.get()
|
||||
try:
|
||||
await self._run(self._deferred.get(type(event), []), event, "subscriber")
|
||||
finally:
|
||||
self._queue.task_done()
|
||||
|
||||
async def _run(self, handlers: Sequence[Any], event: DomainEvent, kind: str) -> None:
|
||||
for handler in handlers:
|
||||
try:
|
||||
await handler(event)
|
||||
except Exception as error:
|
||||
self._logger.error(
|
||||
"event.handler_failed",
|
||||
event_name=event.name,
|
||||
reason=kind,
|
||||
error=type(error).__name__,
|
||||
)
|
||||
|
||||
|
||||
class InMemoryEventPublisher:
|
||||
__slots__ = ("_bus",)
|
||||
|
||||
def __init__(self, bus: EventBus) -> None:
|
||||
self._bus = bus
|
||||
|
||||
async def publish(self, events: Sequence[DomainEvent]) -> None:
|
||||
for event in events:
|
||||
await self._bus.emit(event)
|
||||
@@ -0,0 +1,42 @@
|
||||
from collections.abc import Sequence
|
||||
from contextlib import AbstractAsyncContextManager
|
||||
from datetime import datetime
|
||||
from typing import Any, Protocol, runtime_checkable
|
||||
from uuid import UUID
|
||||
|
||||
from messenger.shared.domain.events import DomainEvent
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class Clock(Protocol):
|
||||
def now(self) -> datetime: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class IdGenerator(Protocol):
|
||||
def new_id(self) -> UUID: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class Logger(Protocol):
|
||||
def info(self, event: str, /, **fields: Any) -> None: ...
|
||||
|
||||
def warning(self, event: str, /, **fields: Any) -> None: ...
|
||||
|
||||
def error(self, event: str, /, **fields: Any) -> None: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class UnitOfWork(Protocol):
|
||||
def transaction(self) -> AbstractAsyncContextManager[None]: ...
|
||||
|
||||
async def commit(self) -> None: ...
|
||||
|
||||
def record(self, event: DomainEvent) -> None: ...
|
||||
|
||||
def collect_new_events(self) -> list[DomainEvent]: ...
|
||||
|
||||
|
||||
@runtime_checkable
|
||||
class EventPublisher(Protocol):
|
||||
async def publish(self, events: Sequence[DomainEvent]) -> None: ...
|
||||
@@ -0,0 +1,48 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from pydantic import Field, SecretStr
|
||||
from pydantic.fields import FieldInfo
|
||||
from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict
|
||||
|
||||
CONFIG = SettingsConfigDict(extra="ignore", frozen=True)
|
||||
|
||||
|
||||
class FileVariables(PydanticBaseSettingsSource):
|
||||
def get_field_value(self, field: FieldInfo, field_name: str) -> tuple[Any, str, bool]:
|
||||
path = os.environ.get(f"{field_name.upper()}_FILE")
|
||||
return (Path(path).read_text().strip() if path else None), field_name, False
|
||||
|
||||
def __call__(self) -> dict[str, Any]:
|
||||
found = {
|
||||
name: self.get_field_value(field, name)[0]
|
||||
for name, field in self.settings_cls.model_fields.items()
|
||||
}
|
||||
return {name: value for name, value in found.items() if value is not None}
|
||||
|
||||
|
||||
class Settings(BaseSettings):
|
||||
model_config = CONFIG
|
||||
|
||||
@classmethod
|
||||
def settings_customise_sources(
|
||||
cls,
|
||||
settings_cls: type[BaseSettings],
|
||||
init_settings: PydanticBaseSettingsSource,
|
||||
env_settings: PydanticBaseSettingsSource,
|
||||
dotenv_settings: PydanticBaseSettingsSource,
|
||||
file_secret_settings: PydanticBaseSettingsSource,
|
||||
) -> tuple[PydanticBaseSettingsSource, ...]:
|
||||
return init_settings, env_settings, FileVariables(settings_cls)
|
||||
|
||||
|
||||
class PlatformSettings(Settings):
|
||||
log_level: str = "INFO"
|
||||
instance_id: str = ""
|
||||
event_queue_max: int = Field(default=10_000, ge=16)
|
||||
database_url: SecretStr
|
||||
db_pool_max_size: int = Field(default=8, ge=1, le=50)
|
||||
db_connect_timeout_seconds: float = Field(default=1.0, gt=0, le=30)
|
||||
db_acquire_timeout_seconds: float = Field(default=1.0, gt=0, le=30)
|
||||
db_command_timeout_seconds: float = Field(default=2.0, gt=0, le=60)
|
||||
@@ -0,0 +1,4 @@
|
||||
class DomainError(Exception):
|
||||
def __init__(self, detail: str) -> None:
|
||||
super().__init__(detail)
|
||||
self.detail = detail
|
||||
@@ -0,0 +1,6 @@
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class DomainEvent:
|
||||
name: str = field(init=False, default="domain.event")
|
||||
@@ -0,0 +1,16 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import Depends, Request
|
||||
|
||||
from messenger.shared.entrypoints.errors import Unauthenticated
|
||||
|
||||
|
||||
async def current_actor(request: Request) -> UUID:
|
||||
actor = getattr(request.state, "actor", None)
|
||||
if not isinstance(actor, UUID):
|
||||
raise Unauthenticated("заголовок идентификации обязателен и должен быть действительным")
|
||||
return actor
|
||||
|
||||
|
||||
type Actor = Annotated[UUID, Depends(current_actor)]
|
||||
@@ -0,0 +1,10 @@
|
||||
from pydantic import Field
|
||||
|
||||
from messenger.shared.config import Settings
|
||||
|
||||
|
||||
class TransportSettings(Settings):
|
||||
docs: bool = False
|
||||
max_body_bytes: int = Field(default=1_048_576, ge=4_096)
|
||||
request_timeout_seconds: float = Field(default=15.0, gt=0, le=300)
|
||||
shutdown_timeout_seconds: int = Field(default=10, ge=1, le=10)
|
||||
@@ -0,0 +1,133 @@
|
||||
from collections.abc import Callable, Mapping
|
||||
|
||||
from fastapi import FastAPI, Request, Response, status
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
from messenger.shared.application.errors import Unavailable
|
||||
from messenger.shared.application.ports import Logger
|
||||
from messenger.shared.domain.errors import DomainError
|
||||
from messenger.shared.entrypoints.schemas import ErrorEnvelope
|
||||
|
||||
REQUEST_ID_HEADER = "X-Request-Id"
|
||||
|
||||
type ErrorCodes = Mapping[type[DomainError], tuple[str, int]]
|
||||
type Challenge = Callable[[str], str]
|
||||
|
||||
MESSAGES = {
|
||||
"invalid_request": "Запрос не соответствует контракту",
|
||||
"unauthorized": "Аутентификация не предоставлена или недействительна",
|
||||
"not_found": "Объект не найден",
|
||||
"conflict": "Конфликт состояния",
|
||||
"payload_too_large": "Тело запроса больше допустимого",
|
||||
"unsupported_media_type": "Неподдерживаемый тип содержимого",
|
||||
"rate_limited": "Слишком много запросов",
|
||||
"unavailable": "Сервис временно недоступен",
|
||||
"internal_error": "Внутренняя ошибка",
|
||||
}
|
||||
|
||||
STATUS_CODES = {
|
||||
status.HTTP_400_BAD_REQUEST: "invalid_request",
|
||||
status.HTTP_401_UNAUTHORIZED: "unauthorized",
|
||||
status.HTTP_404_NOT_FOUND: "not_found",
|
||||
status.HTTP_409_CONFLICT: "conflict",
|
||||
status.HTTP_413_CONTENT_TOO_LARGE: "payload_too_large",
|
||||
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE: "unsupported_media_type",
|
||||
status.HTTP_422_UNPROCESSABLE_CONTENT: "invalid_request",
|
||||
status.HTTP_429_TOO_MANY_REQUESTS: "rate_limited",
|
||||
status.HTTP_503_SERVICE_UNAVAILABLE: "unavailable",
|
||||
}
|
||||
|
||||
|
||||
class Unauthenticated(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def classify(error: DomainError, codes: ErrorCodes) -> tuple[str, int]:
|
||||
for kind in type(error).__mro__:
|
||||
known = codes.get(kind) # type: ignore[arg-type]
|
||||
if known is not None:
|
||||
return known
|
||||
return "internal_error", status.HTTP_500_INTERNAL_SERVER_ERROR
|
||||
|
||||
|
||||
def route_of(request: Request) -> str:
|
||||
route = request.scope.get("route")
|
||||
return getattr(route, "path", request.url.path)
|
||||
|
||||
|
||||
def install(app: FastAPI, logger: Logger, codes: ErrorCodes, challenge: Challenge) -> None:
|
||||
def error_response(request: Request, code: str, detail: str, http_status: int) -> Response:
|
||||
request_id = getattr(request.state, "request_id", "") or "unknown"
|
||||
headers = {REQUEST_ID_HEADER: request_id}
|
||||
if http_status == status.HTTP_401_UNAUTHORIZED:
|
||||
headers["WWW-Authenticate"] = challenge(request.url.path)
|
||||
return Response(
|
||||
status_code=http_status,
|
||||
content=ErrorEnvelope.of(code, detail, request_id).model_dump_json(),
|
||||
media_type="application/json",
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
@app.exception_handler(DomainError)
|
||||
async def _domain(request: Request, exc: DomainError) -> Response:
|
||||
code, http_status = classify(exc, codes)
|
||||
return error_response(request, code, exc.detail, http_status)
|
||||
|
||||
@app.exception_handler(Unavailable)
|
||||
async def _unavailable(request: Request, exc: Unavailable) -> Response:
|
||||
logger.warning(
|
||||
"dependency.unavailable",
|
||||
route=route_of(request),
|
||||
error=type(exc.__cause__ or exc).__name__,
|
||||
request_id=getattr(request.state, "request_id", None),
|
||||
)
|
||||
return error_response(
|
||||
request,
|
||||
"unavailable",
|
||||
MESSAGES["unavailable"],
|
||||
status.HTTP_503_SERVICE_UNAVAILABLE,
|
||||
)
|
||||
|
||||
@app.exception_handler(Unauthenticated)
|
||||
async def _unauthenticated(request: Request, _exc: Unauthenticated) -> Response:
|
||||
return error_response(
|
||||
request,
|
||||
"unauthorized",
|
||||
MESSAGES["unauthorized"],
|
||||
status.HTTP_401_UNAUTHORIZED,
|
||||
)
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def _validation(request: Request, _exc: RequestValidationError) -> Response:
|
||||
return error_response(
|
||||
request,
|
||||
"invalid_request",
|
||||
MESSAGES["invalid_request"],
|
||||
status.HTTP_400_BAD_REQUEST,
|
||||
)
|
||||
|
||||
@app.exception_handler(HTTPException)
|
||||
async def _http(request: Request, exc: HTTPException) -> Response:
|
||||
http_status = exc.status_code
|
||||
if http_status == status.HTTP_405_METHOD_NOT_ALLOWED:
|
||||
http_status = status.HTTP_404_NOT_FOUND
|
||||
code = STATUS_CODES.get(http_status, "internal_error")
|
||||
return error_response(
|
||||
request, code, MESSAGES.get(code, MESSAGES["internal_error"]), http_status
|
||||
)
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def _unexpected(request: Request, exc: Exception) -> Response:
|
||||
logger.error(
|
||||
"request.failed",
|
||||
route=route_of(request),
|
||||
error=type(exc).__name__,
|
||||
request_id=getattr(request.state, "request_id", None),
|
||||
)
|
||||
return error_response(
|
||||
request,
|
||||
"internal_error",
|
||||
MESSAGES["internal_error"],
|
||||
status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
)
|
||||
@@ -0,0 +1,19 @@
|
||||
from dishka.integrations.fastapi import FromDishka, inject
|
||||
from fastapi import APIRouter
|
||||
|
||||
from messenger.shared.entrypoints.schemas import HealthOut
|
||||
from messenger.shared.infrastructure.postgres import Database
|
||||
|
||||
router = APIRouter(tags=["health"])
|
||||
|
||||
|
||||
@router.get("/health/live")
|
||||
async def live() -> HealthOut:
|
||||
return HealthOut()
|
||||
|
||||
|
||||
@router.get("/health/ready")
|
||||
@inject
|
||||
async def ready(database: FromDishka[Database]) -> HealthOut:
|
||||
await database.ping()
|
||||
return HealthOut()
|
||||
@@ -0,0 +1,54 @@
|
||||
from collections.abc import AsyncIterator
|
||||
|
||||
from dishka import Provider, Scope, provide
|
||||
|
||||
from messenger.shared.application.messagebus import EventBus, InMemoryEventPublisher
|
||||
from messenger.shared.application.ports import Clock, EventPublisher, IdGenerator, Logger
|
||||
from messenger.shared.config import PlatformSettings
|
||||
from messenger.shared.infrastructure.clock import MonotonicUtcClock
|
||||
from messenger.shared.infrastructure.ids import Uuid7Generator
|
||||
from messenger.shared.infrastructure.postgres import Database
|
||||
|
||||
|
||||
class PlatformProvider(Provider):
|
||||
def __init__(self, settings: PlatformSettings, logger: Logger) -> None:
|
||||
super().__init__()
|
||||
self._settings = settings
|
||||
self._logger = logger
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def settings(self) -> PlatformSettings:
|
||||
return self._settings
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def logger(self) -> Logger:
|
||||
return self._logger
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def clock(self) -> Clock:
|
||||
return MonotonicUtcClock()
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def ids(self) -> IdGenerator:
|
||||
return Uuid7Generator()
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
async def database(self, settings: PlatformSettings) -> AsyncIterator[Database]:
|
||||
database = Database(
|
||||
settings.database_url.get_secret_value(),
|
||||
max_size=settings.db_pool_max_size,
|
||||
connect_timeout=settings.db_connect_timeout_seconds,
|
||||
acquire_timeout=settings.db_acquire_timeout_seconds,
|
||||
command_timeout=settings.db_command_timeout_seconds,
|
||||
)
|
||||
await database.open()
|
||||
yield database
|
||||
await database.close()
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def event_bus(self, logger: Logger, settings: PlatformSettings) -> EventBus:
|
||||
return EventBus(logger, max_queue=settings.event_queue_max)
|
||||
|
||||
@provide(scope=Scope.APP)
|
||||
def publisher(self, bus: EventBus) -> EventPublisher:
|
||||
return InMemoryEventPublisher(bus)
|
||||
@@ -0,0 +1,160 @@
|
||||
import asyncio
|
||||
import time
|
||||
from collections.abc import Awaitable, Callable
|
||||
from dataclasses import dataclass
|
||||
from uuid import uuid4
|
||||
|
||||
from starlette.types import ASGIApp, Message, Receive, Scope, Send
|
||||
|
||||
from messenger.shared.application.errors import Unavailable
|
||||
from messenger.shared.application.ports import Logger
|
||||
from messenger.shared.entrypoints.errors import MESSAGES, REQUEST_ID_HEADER
|
||||
from messenger.shared.entrypoints.schemas import ErrorEnvelope
|
||||
|
||||
type Headers = tuple[tuple[str, str], ...]
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Rejection:
|
||||
status: int
|
||||
code: str
|
||||
headers: Headers = ()
|
||||
|
||||
|
||||
type Guard = Callable[[Scope], Awaitable[Rejection | None]]
|
||||
|
||||
HEADER_BYTES = REQUEST_ID_HEADER.lower().encode()
|
||||
MAX_REQUEST_ID = 200
|
||||
|
||||
|
||||
def header(scope: Scope, name: bytes) -> str:
|
||||
for key, value in scope["headers"]:
|
||||
if key == name:
|
||||
return value.decode("latin-1").strip()
|
||||
return ""
|
||||
|
||||
|
||||
async def send_error(
|
||||
send: Send, status: int, code: str, request_id: str, headers: Headers = ()
|
||||
) -> None:
|
||||
body = ErrorEnvelope.of(code, MESSAGES[code], request_id).model_dump_json().encode()
|
||||
await send(
|
||||
{
|
||||
"type": "http.response.start",
|
||||
"status": status,
|
||||
"headers": [
|
||||
(b"content-type", b"application/json"),
|
||||
(b"content-length", str(len(body)).encode()),
|
||||
(HEADER_BYTES, request_id.encode("latin-1", "replace")),
|
||||
*((name.encode(), value.encode("latin-1")) for name, value in headers),
|
||||
],
|
||||
}
|
||||
)
|
||||
await send({"type": "http.response.body", "body": body})
|
||||
|
||||
|
||||
class RequestPipeline:
|
||||
__slots__ = ("_app", "_guard", "_logger", "_max_bytes", "_timeout")
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
app: ASGIApp,
|
||||
logger: Logger,
|
||||
max_bytes: int,
|
||||
timeout: float,
|
||||
guard: Guard,
|
||||
) -> None:
|
||||
self._app = app
|
||||
self._logger = logger
|
||||
self._max_bytes = max_bytes
|
||||
self._timeout = timeout
|
||||
self._guard = guard
|
||||
|
||||
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
|
||||
if scope["type"] != "http":
|
||||
await self._app(scope, receive, send)
|
||||
return
|
||||
|
||||
incoming = header(scope, HEADER_BYTES)
|
||||
request_id = incoming[:MAX_REQUEST_ID] if incoming else uuid4().hex
|
||||
state = scope.setdefault("state", {})
|
||||
state["request_id"] = request_id
|
||||
state["actor"] = None
|
||||
started = time.perf_counter()
|
||||
status_holder = [500]
|
||||
answered = [False]
|
||||
|
||||
async def wrapped_send(message: Message) -> None:
|
||||
if message["type"] == "http.response.start":
|
||||
status_holder[0] = message["status"]
|
||||
answered[0] = True
|
||||
headers = [
|
||||
(key, value)
|
||||
for key, value in message.get("headers", [])
|
||||
if key.lower() != HEADER_BYTES
|
||||
]
|
||||
headers.append((HEADER_BYTES, request_id.encode("latin-1", "replace")))
|
||||
message = {**message, "headers": headers}
|
||||
await send(message)
|
||||
|
||||
declared = header(scope, b"content-length")
|
||||
if declared.isdigit() and int(declared) > self._max_bytes:
|
||||
await send_error(wrapped_send, 413, "payload_too_large", request_id)
|
||||
self._log(scope, status_holder[0], request_id, started)
|
||||
return
|
||||
|
||||
rejection: Rejection | None = None
|
||||
try:
|
||||
async with asyncio.timeout(self._timeout):
|
||||
rejection = await self._guard(scope)
|
||||
if rejection is None:
|
||||
await self._app(scope, receive, wrapped_send)
|
||||
except Unavailable as error:
|
||||
self._logger.warning(
|
||||
"dependency.unavailable",
|
||||
route=self._route(scope),
|
||||
error=type(error.__cause__ or error).__name__,
|
||||
request_id=request_id,
|
||||
)
|
||||
rejection = Rejection(503, "unavailable")
|
||||
except TimeoutError:
|
||||
self._logger.warning(
|
||||
"request.timeout",
|
||||
method=scope["method"],
|
||||
route=self._route(scope),
|
||||
request_id=request_id,
|
||||
limit=self._timeout,
|
||||
duration_ms=round((time.perf_counter() - started) * 1000, 3),
|
||||
)
|
||||
if not answered[0]:
|
||||
await send_error(wrapped_send, 503, "unavailable", request_id)
|
||||
self._log(scope, status_holder[0], request_id, started)
|
||||
return
|
||||
except Exception:
|
||||
self._logger.error(
|
||||
"request.unhandled",
|
||||
method=scope["method"],
|
||||
route=self._route(scope),
|
||||
request_id=request_id,
|
||||
duration_ms=round((time.perf_counter() - started) * 1000, 3),
|
||||
)
|
||||
raise
|
||||
if rejection is not None and not answered[0]:
|
||||
await send_error(
|
||||
wrapped_send, rejection.status, rejection.code, request_id, rejection.headers
|
||||
)
|
||||
self._log(scope, status_holder[0], request_id, started)
|
||||
|
||||
def _route(self, scope: Scope) -> str:
|
||||
route = scope.get("route")
|
||||
return getattr(route, "path", scope["path"])
|
||||
|
||||
def _log(self, scope: Scope, status: int, request_id: str, started: float) -> None:
|
||||
self._logger.info(
|
||||
"request.handled",
|
||||
method=scope["method"],
|
||||
route=self._route(scope),
|
||||
status=status,
|
||||
request_id=request_id,
|
||||
duration_ms=round((time.perf_counter() - started) * 1000, 3),
|
||||
)
|
||||
@@ -0,0 +1,21 @@
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class ErrorDetail(BaseModel):
|
||||
code: str
|
||||
message: str
|
||||
request_id: str
|
||||
|
||||
|
||||
class ErrorEnvelope(BaseModel):
|
||||
error: ErrorDetail
|
||||
|
||||
@classmethod
|
||||
def of(cls, code: str, message: str, request_id: str) -> ErrorEnvelope:
|
||||
return cls(error=ErrorDetail(code=code, message=message, request_id=request_id))
|
||||
|
||||
|
||||
class HealthOut(BaseModel):
|
||||
status: Literal["ok"] = "ok"
|
||||
@@ -0,0 +1,17 @@
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
TICK = timedelta(microseconds=1)
|
||||
|
||||
|
||||
class MonotonicUtcClock:
|
||||
__slots__ = ("_last",)
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._last: datetime | None = None
|
||||
|
||||
def now(self) -> datetime:
|
||||
current = datetime.now(UTC)
|
||||
if self._last is not None and current <= self._last:
|
||||
current = self._last + TICK
|
||||
self._last = current
|
||||
return current
|
||||
@@ -0,0 +1,8 @@
|
||||
from uuid import UUID, uuid7
|
||||
|
||||
|
||||
class Uuid7Generator:
|
||||
__slots__ = ()
|
||||
|
||||
def new_id(self) -> UUID:
|
||||
return uuid7()
|
||||
@@ -0,0 +1,113 @@
|
||||
import logging
|
||||
import sys
|
||||
from typing import Any
|
||||
|
||||
import orjson
|
||||
import structlog
|
||||
from structlog.typing import EventDict, Processor, WrappedLogger
|
||||
|
||||
PLATFORM_FIELDS = frozenset(
|
||||
{
|
||||
"method",
|
||||
"route",
|
||||
"status",
|
||||
"duration_ms",
|
||||
"request_id",
|
||||
"event_name",
|
||||
"error",
|
||||
"reason",
|
||||
"limit",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def render(obj: object, **_kwargs: object) -> str:
|
||||
return orjson.dumps(obj).decode()
|
||||
|
||||
|
||||
RESERVED = frozenset({"event", "level", "ts", "logger"})
|
||||
|
||||
FOREIGN_LOGGERS = (
|
||||
"uvicorn",
|
||||
"uvicorn.error",
|
||||
"gunicorn",
|
||||
"gunicorn.error",
|
||||
"asyncio",
|
||||
)
|
||||
|
||||
SILENCED_LOGGERS = ("uvicorn.access", "gunicorn.access")
|
||||
|
||||
|
||||
def field_filter(allowed: frozenset[str]) -> Processor:
|
||||
def drop_unlisted_fields(
|
||||
_logger: WrappedLogger, _method: str, event_dict: EventDict
|
||||
) -> EventDict:
|
||||
return {
|
||||
key: value
|
||||
for key, value in event_dict.items()
|
||||
if (key in RESERVED or key in allowed) and value is not None
|
||||
}
|
||||
|
||||
return drop_unlisted_fields
|
||||
|
||||
|
||||
def configure(level: str = "INFO", allowed_fields: frozenset[str] = PLATFORM_FIELDS) -> None:
|
||||
shared = [
|
||||
structlog.contextvars.merge_contextvars,
|
||||
structlog.processors.add_log_level,
|
||||
structlog.processors.TimeStamper(fmt="iso", utc=True, key="ts"),
|
||||
]
|
||||
structlog.configure(
|
||||
processors=[*shared, structlog.stdlib.ProcessorFormatter.wrap_for_formatter],
|
||||
logger_factory=structlog.stdlib.LoggerFactory(),
|
||||
wrapper_class=structlog.stdlib.BoundLogger,
|
||||
cache_logger_on_first_use=False,
|
||||
)
|
||||
handler = logging.StreamHandler(sys.stdout)
|
||||
handler.setFormatter(
|
||||
structlog.stdlib.ProcessorFormatter(
|
||||
foreign_pre_chain=shared,
|
||||
processors=[
|
||||
structlog.stdlib.ProcessorFormatter.remove_processors_meta,
|
||||
field_filter(allowed_fields),
|
||||
structlog.processors.JSONRenderer(serializer=render),
|
||||
],
|
||||
)
|
||||
)
|
||||
root = logging.getLogger()
|
||||
for existing in list(root.handlers):
|
||||
root.removeHandler(existing)
|
||||
root.addHandler(handler)
|
||||
root.setLevel(level.upper())
|
||||
for name in FOREIGN_LOGGERS:
|
||||
foreign = logging.getLogger(name)
|
||||
for existing in list(foreign.handlers):
|
||||
foreign.removeHandler(existing)
|
||||
foreign.propagate = True
|
||||
for name in SILENCED_LOGGERS:
|
||||
silenced = logging.getLogger(name)
|
||||
for existing in list(silenced.handlers):
|
||||
silenced.removeHandler(existing)
|
||||
silenced.propagate = False
|
||||
|
||||
|
||||
class StructlogLogger:
|
||||
__slots__ = ("_logger",)
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
name: str = "messenger",
|
||||
level: str = "INFO",
|
||||
allowed_fields: frozenset[str] = PLATFORM_FIELDS,
|
||||
) -> None:
|
||||
configure(level, allowed_fields)
|
||||
self._logger = structlog.get_logger(name)
|
||||
|
||||
def info(self, event: str, /, **fields: Any) -> None:
|
||||
self._logger.info(event, **fields)
|
||||
|
||||
def warning(self, event: str, /, **fields: Any) -> None:
|
||||
self._logger.warning(event, **fields)
|
||||
|
||||
def error(self, event: str, /, **fields: Any) -> None:
|
||||
self._logger.error(event, **fields)
|
||||
@@ -0,0 +1,115 @@
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
from typing import Any, Protocol
|
||||
|
||||
import asyncpg
|
||||
|
||||
from messenger.shared.application.errors import Unavailable
|
||||
from messenger.shared.domain.events import DomainEvent
|
||||
|
||||
FAILURES = (
|
||||
OSError,
|
||||
asyncpg.InterfaceError,
|
||||
asyncpg.PostgresConnectionError,
|
||||
asyncpg.exceptions.OperatorInterventionError,
|
||||
asyncpg.exceptions.InsufficientResourcesError,
|
||||
)
|
||||
|
||||
type Connection = asyncpg.Connection
|
||||
|
||||
|
||||
class EventSource(Protocol):
|
||||
def collect_events(self) -> list[DomainEvent]: ...
|
||||
|
||||
|
||||
class Database:
|
||||
__slots__ = ("_acquire_timeout", "_pool")
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
dsn: str,
|
||||
*,
|
||||
max_size: int,
|
||||
connect_timeout: float,
|
||||
acquire_timeout: float,
|
||||
command_timeout: float,
|
||||
) -> None:
|
||||
self._acquire_timeout = acquire_timeout
|
||||
self._pool = asyncpg.create_pool(
|
||||
dsn,
|
||||
min_size=0,
|
||||
max_size=max_size,
|
||||
timeout=connect_timeout,
|
||||
command_timeout=command_timeout,
|
||||
max_inactive_connection_lifetime=60,
|
||||
server_settings={
|
||||
"statement_timeout": str(int(command_timeout * 1000)),
|
||||
"lock_timeout": str(int(command_timeout * 1000)),
|
||||
"idle_in_transaction_session_timeout": "10000",
|
||||
},
|
||||
)
|
||||
|
||||
async def open(self) -> None:
|
||||
await self._pool
|
||||
|
||||
async def close(self) -> None:
|
||||
await self._pool.close()
|
||||
|
||||
@asynccontextmanager
|
||||
async def connection(self) -> AsyncIterator[Connection]:
|
||||
try:
|
||||
async with self._pool.acquire(timeout=self._acquire_timeout) as connection:
|
||||
yield connection
|
||||
except FAILURES as error:
|
||||
raise Unavailable("PostgreSQL недоступен") from error
|
||||
|
||||
async def ping(self) -> None:
|
||||
async with self.connection() as connection:
|
||||
await connection.fetchval("SELECT 1", timeout=1)
|
||||
|
||||
|
||||
class PostgresUnitOfWork:
|
||||
__slots__ = ("_committed", "_connection", "_database", "_events", "_transaction", "seen")
|
||||
|
||||
def __init__(self, database: Database) -> None:
|
||||
self._database = database
|
||||
self._connection: Connection | None = None
|
||||
self._transaction: Any = None
|
||||
self._committed = False
|
||||
self._events: list[DomainEvent] = []
|
||||
self.seen: list[EventSource] = []
|
||||
|
||||
@property
|
||||
def connection(self) -> Connection:
|
||||
if self._connection is None:
|
||||
raise RuntimeError("репозиторий используется вне транзакции")
|
||||
return self._connection
|
||||
|
||||
@asynccontextmanager
|
||||
async def transaction(self) -> AsyncIterator[None]:
|
||||
async with self._database.connection() as connection:
|
||||
self._connection = connection
|
||||
self._transaction = connection.transaction()
|
||||
await self._transaction.start()
|
||||
self._committed = False
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
if not self._committed:
|
||||
self._events.clear()
|
||||
await self._transaction.rollback()
|
||||
self.seen.clear()
|
||||
self._connection = None
|
||||
|
||||
async def commit(self) -> None:
|
||||
await self._transaction.commit()
|
||||
self._committed = True
|
||||
for source in self.seen:
|
||||
self._events.extend(source.collect_events())
|
||||
|
||||
def record(self, event: DomainEvent) -> None:
|
||||
self._events.append(event)
|
||||
|
||||
def collect_new_events(self) -> list[DomainEvent]:
|
||||
events, self._events = self._events, []
|
||||
return events
|
||||
@@ -0,0 +1,84 @@
|
||||
from uuid import uuid4
|
||||
|
||||
from httpx import AsyncClient
|
||||
|
||||
from conftest import actor, make_chat, register
|
||||
|
||||
|
||||
async def test_outsider_gets_404_on_chat(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
response = await client.get(f"/api/v1/chats/{chat['id']}", headers=actor(eve))
|
||||
assert response.status_code == 404
|
||||
assert response.json()["error"]["code"] == "not_found"
|
||||
|
||||
|
||||
async def test_unknown_chat_is_indistinguishable_from_foreign(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice)
|
||||
foreign = await client.get(f"/api/v1/chats/{chat['id']}", headers=actor(eve))
|
||||
missing = await client.get(f"/api/v1/chats/{uuid4()}", headers=actor(eve))
|
||||
assert foreign.status_code == missing.status_code == 404
|
||||
assert foreign.json()["error"]["code"] == missing.json()["error"]["code"]
|
||||
assert foreign.json()["error"]["message"] == missing.json()["error"]["message"]
|
||||
|
||||
|
||||
async def test_outsider_cannot_write(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice)
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": "чужое"},
|
||||
headers=actor(eve),
|
||||
)
|
||||
assert response.status_code == 404
|
||||
history = await client.get(f"/api/v1/chats/{chat['id']}/messages", headers=actor(alice))
|
||||
assert history.json()["items"] == []
|
||||
|
||||
|
||||
async def test_outsider_cannot_read_history(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice)
|
||||
response = await client.get(f"/api/v1/chats/{chat['id']}/messages", headers=actor(eve))
|
||||
assert response.status_code == 404
|
||||
|
||||
|
||||
async def test_access_checked_before_body(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice)
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": ""},
|
||||
headers=actor(eve),
|
||||
)
|
||||
assert response.status_code == 404
|
||||
|
||||
|
||||
async def test_chat_list_hides_foreign_chats(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
for member in (alice, bob):
|
||||
listed = await client.get("/api/v1/chats?limit=100", headers=actor(member))
|
||||
assert any(item["id"] == chat["id"] for item in listed.json()["items"])
|
||||
hidden = await client.get("/api/v1/chats?limit=100", headers=actor(eve))
|
||||
assert hidden.json()["items"] == []
|
||||
|
||||
|
||||
async def test_403_is_never_used(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice)
|
||||
paths = [
|
||||
f"/api/v1/chats/{chat['id']}",
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
]
|
||||
for path in paths:
|
||||
assert (await client.get(path, headers=actor(eve))).status_code != 403
|
||||
@@ -0,0 +1,242 @@
|
||||
import ast
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
SOURCE = Path(__file__).resolve().parents[2] / "src" / "messenger"
|
||||
IDENTITY = "messenger.identity"
|
||||
MESSAGING = "messenger.messaging"
|
||||
|
||||
|
||||
def imports_of(path: Path) -> list[str]:
|
||||
tree = ast.parse(path.read_text(), filename=str(path))
|
||||
found: list[str] = []
|
||||
for node in ast.walk(tree):
|
||||
if isinstance(node, ast.ImportFrom) and node.module:
|
||||
found.append(node.module)
|
||||
elif isinstance(node, ast.Import):
|
||||
found.extend(alias.name for alias in node.names)
|
||||
return found
|
||||
|
||||
|
||||
def modules_under(*parts: str) -> list[Path]:
|
||||
root = SOURCE.joinpath(*parts)
|
||||
return [path for path in root.rglob("*.py") if path.name != "__init__.py"]
|
||||
|
||||
|
||||
def test_identity_does_not_know_about_messaging() -> None:
|
||||
offenders = {
|
||||
str(path.relative_to(SOURCE)): [m for m in imports_of(path) if m.startswith(MESSAGING)]
|
||||
for path in modules_under("identity")
|
||||
}
|
||||
assert not {k: v for k, v in offenders.items() if v}
|
||||
|
||||
|
||||
def test_messaging_touches_identity_only_through_events() -> None:
|
||||
allowed = f"{IDENTITY}.domain.events"
|
||||
offenders: dict[str, list[str]] = {}
|
||||
for path in modules_under("messaging"):
|
||||
borrowed = [
|
||||
module
|
||||
for module in imports_of(path)
|
||||
if module.startswith(IDENTITY) and module != allowed
|
||||
]
|
||||
if borrowed:
|
||||
offenders[str(path.relative_to(SOURCE))] = borrowed
|
||||
assert not offenders
|
||||
|
||||
|
||||
def test_domains_do_not_import_infrastructure() -> None:
|
||||
offenders: dict[str, list[str]] = {}
|
||||
for zone in ("identity", "messaging", "shared"):
|
||||
for layer in ("domain", "application"):
|
||||
for path in modules_under(zone, layer):
|
||||
borrowed = [m for m in imports_of(path) if ".infrastructure" in m]
|
||||
if borrowed:
|
||||
offenders[str(path.relative_to(SOURCE))] = borrowed
|
||||
assert not offenders
|
||||
|
||||
|
||||
def test_core_layers_do_not_import_pydantic() -> None:
|
||||
offenders: dict[str, list[str]] = {}
|
||||
for zone in ("identity", "messaging", "shared"):
|
||||
for layer in ("domain", "application"):
|
||||
for path in modules_under(zone, layer):
|
||||
borrowed = [m for m in imports_of(path) if m.split(".")[0] == "pydantic"]
|
||||
if borrowed:
|
||||
offenders[str(path.relative_to(SOURCE))] = borrowed
|
||||
assert not offenders, "схемы pydantic живут на границе: в entrypoints/ и config.py"
|
||||
|
||||
|
||||
def test_shared_knows_nothing_about_zones() -> None:
|
||||
offenders: dict[str, list[str]] = {}
|
||||
for path in modules_under("shared"):
|
||||
borrowed = [
|
||||
module
|
||||
for module in imports_of(path)
|
||||
if module.startswith(IDENTITY) or module.startswith(MESSAGING)
|
||||
]
|
||||
if borrowed:
|
||||
offenders[str(path.relative_to(SOURCE))] = borrowed
|
||||
assert not offenders
|
||||
|
||||
|
||||
TRANSPORT = ("fastapi", "starlette", "uvicorn", "gunicorn")
|
||||
|
||||
|
||||
def test_shared_core_is_free_of_transport() -> None:
|
||||
offenders: dict[str, list[str]] = {}
|
||||
for layer in ("domain", "application", "infrastructure"):
|
||||
for path in modules_under("shared", layer):
|
||||
borrowed = [module for module in imports_of(path) if module.split(".")[0] in TRANSPORT]
|
||||
if borrowed:
|
||||
offenders[str(path.relative_to(SOURCE))] = borrowed
|
||||
assert not offenders, "ядро shared обязано жить без веб-фреймворка"
|
||||
|
||||
|
||||
def test_shared_core_holds_only_platform() -> None:
|
||||
names = {
|
||||
path.name
|
||||
for layer in ("domain", "application", "infrastructure")
|
||||
for path in modules_under("shared", layer)
|
||||
}
|
||||
assert names == {
|
||||
"errors.py",
|
||||
"events.py",
|
||||
"commands.py",
|
||||
"messagebus.py",
|
||||
"ports.py",
|
||||
"clock.py",
|
||||
"ids.py",
|
||||
"logging.py",
|
||||
"postgres.py",
|
||||
}
|
||||
|
||||
|
||||
def test_shared_entrypoints_hold_only_transport() -> None:
|
||||
names = {path.name for path in modules_under("shared", "entrypoints")}
|
||||
assert names == {
|
||||
"actor.py",
|
||||
"config.py",
|
||||
"errors.py",
|
||||
"health.py",
|
||||
"ioc.py",
|
||||
"pipeline.py",
|
||||
"schemas.py",
|
||||
}
|
||||
|
||||
|
||||
def test_every_zone_owns_its_errors_events_and_commands() -> None:
|
||||
for zone in ("identity", "messaging"):
|
||||
assert (SOURCE / zone / "domain" / "errors.py").is_file()
|
||||
assert (SOURCE / zone / "domain" / "events.py").is_file()
|
||||
assert (SOURCE / zone / "application" / "commands.py").is_file()
|
||||
|
||||
|
||||
def test_every_zone_owns_its_http_layer() -> None:
|
||||
for zone in ("identity", "messaging"):
|
||||
for part in ("http.py", "ioc.py", "errors.py", "journal.py"):
|
||||
assert (SOURCE / zone / "entrypoints" / part).is_file(), f"{zone}: нет {part}"
|
||||
|
||||
|
||||
def test_only_main_knows_both_zones() -> None:
|
||||
offenders: dict[str, list[str]] = {}
|
||||
for path in SOURCE.rglob("*.py"):
|
||||
relative = path.relative_to(SOURCE)
|
||||
if path.name in {"__init__.py", "main.py"} or relative.parts[0] in {
|
||||
"identity",
|
||||
"messaging",
|
||||
}:
|
||||
continue
|
||||
borrowed = [
|
||||
module
|
||||
for module in imports_of(path)
|
||||
if module.startswith(IDENTITY) or module.startswith(MESSAGING)
|
||||
]
|
||||
if borrowed:
|
||||
offenders[str(relative)] = borrowed
|
||||
assert not offenders
|
||||
|
||||
|
||||
def test_application_has_no_separate_entrypoints_root() -> None:
|
||||
assert not (SOURCE / "entrypoints").exists()
|
||||
assert (SOURCE / "main.py").is_file()
|
||||
|
||||
|
||||
ZONE_WORDS = (
|
||||
"username",
|
||||
"display_name",
|
||||
"chat",
|
||||
"member",
|
||||
"history",
|
||||
"cursor",
|
||||
"sender",
|
||||
"message_id",
|
||||
"message_text",
|
||||
)
|
||||
|
||||
|
||||
def test_shared_source_mentions_no_domain_vocabulary() -> None:
|
||||
offenders: dict[str, list[str]] = {}
|
||||
for path in modules_under("shared"):
|
||||
source = path.read_text().lower()
|
||||
hits = sorted({word for word in ZONE_WORDS if word in source})
|
||||
if hits:
|
||||
offenders[str(path.relative_to(SOURCE))] = hits
|
||||
assert not offenders
|
||||
|
||||
|
||||
def test_shared_declares_no_concrete_commands_or_events() -> None:
|
||||
for path in modules_under("shared"):
|
||||
tree = ast.parse(path.read_text(), filename=str(path))
|
||||
declared = [n.name for n in ast.walk(tree) if isinstance(n, ast.ClassDef)]
|
||||
concrete = [
|
||||
name
|
||||
for name in declared
|
||||
if name not in {"Command", "DomainEvent", "DomainError"}
|
||||
and (name.endswith("Event") or name in {"RegisterUser", "CreateChat", "PostMessage"})
|
||||
]
|
||||
assert not concrete, f"{path.name}: {concrete}"
|
||||
|
||||
|
||||
def test_shared_has_no_test_doubles() -> None:
|
||||
for path in modules_under("shared"):
|
||||
source = path.read_text()
|
||||
for marker in ("Frozen", "Fake", "Stub", "Null", "Dummy"):
|
||||
assert marker not in source, f"{path.name} содержит подделку {marker}"
|
||||
|
||||
|
||||
def test_zone_errors_do_not_leak_transport_codes() -> None:
|
||||
for zone in ("identity", "messaging", "shared"):
|
||||
source = (SOURCE / zone / "domain" / "errors.py").read_text()
|
||||
assert "http_status" not in source
|
||||
assert "invalid_request" not in source
|
||||
assert "404" not in source
|
||||
|
||||
|
||||
IDENTITY_TABLES = ("users", "sessions")
|
||||
MESSAGING_TABLES = ("chats", "chat_members", "messages")
|
||||
|
||||
|
||||
def sql_tables(zone: str, tables: tuple[str, ...]) -> set[str]:
|
||||
words: set[str] = set()
|
||||
for path in modules_under(zone):
|
||||
tree = ast.parse(path.read_text(), filename=str(path))
|
||||
for node in ast.walk(tree):
|
||||
if isinstance(node, ast.Constant) and isinstance(node.value, str):
|
||||
words.update(re.findall(r"\b(?:FROM|JOIN|INTO|UPDATE)\s+(\w+)", node.value))
|
||||
return words & set(tables)
|
||||
|
||||
|
||||
def test_sql_of_each_zone_reads_only_its_tables() -> None:
|
||||
assert sql_tables("messaging", IDENTITY_TABLES) == set()
|
||||
assert sql_tables("identity", MESSAGING_TABLES) == set()
|
||||
assert sql_tables("messaging", MESSAGING_TABLES) == set(MESSAGING_TABLES)
|
||||
assert sql_tables("identity", IDENTITY_TABLES) == set(IDENTITY_TABLES)
|
||||
|
||||
|
||||
def test_messaging_does_not_import_identity_at_all() -> None:
|
||||
borrowed = {
|
||||
str(path.relative_to(SOURCE)): [m for m in imports_of(path) if m.startswith(IDENTITY)]
|
||||
for path in modules_under("messaging")
|
||||
}
|
||||
assert not {key: value for key, value in borrowed.items() if value}
|
||||
@@ -0,0 +1,118 @@
|
||||
import asyncio
|
||||
import time
|
||||
from datetime import datetime
|
||||
from hashlib import sha256
|
||||
|
||||
from redis.asyncio import Redis
|
||||
|
||||
from conftest import actor, bearer, register, resolve, running_app, scalar
|
||||
from messenger.identity.application.ports import SessionDirectory
|
||||
from messenger.identity.domain.models import Session
|
||||
from messenger.identity.infrastructure.valkey import CachedSessionDirectory
|
||||
|
||||
BEARER = 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
def key_of(token: str) -> str:
|
||||
return f"session:{sha256(token.encode()).hexdigest()}"
|
||||
|
||||
|
||||
def token_of(user: dict) -> str:
|
||||
return actor(user)["Authorization"].split()[1]
|
||||
|
||||
|
||||
async def test_second_check_is_served_from_cache(valkey: dict[str, str]) -> None:
|
||||
cache = Redis.from_url(valkey["url"])
|
||||
async with running_app(cache_url=valkey["url"]) as http:
|
||||
alice = await register(http, "alice")
|
||||
assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200
|
||||
hits = (await cache.info("stats"))["keyspace_hits"]
|
||||
assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200
|
||||
assert (await cache.info("stats"))["keyspace_hits"] == hits + 1
|
||||
key = key_of(token_of(alice))
|
||||
stored = str(await cache.get(key))
|
||||
sql = "SELECT expires_at FROM sessions WHERE user_id = $1::uuid"
|
||||
expires_at: datetime = await scalar(sql, alice["id"])
|
||||
assert alice["id"] in stored and token_of(alice) not in stored
|
||||
assert await cache.pexpiretime(key) <= int(expires_at.timestamp() * 1000)
|
||||
await cache.aclose()
|
||||
|
||||
|
||||
async def test_logout_writes_tombstone_before_database(valkey: dict[str, str]) -> None:
|
||||
cache = Redis.from_url(valkey["url"])
|
||||
async with running_app(cache_url=valkey["url"]) as http:
|
||||
alice = await register(http, "alice")
|
||||
assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200
|
||||
assert (
|
||||
await http.delete("/api/v1/auth/sessions/current", headers=actor(alice))
|
||||
).status_code == 204
|
||||
assert await cache.get(key_of(token_of(alice))) == b"-"
|
||||
response = await http.get("/api/v1/users/me", headers=actor(alice))
|
||||
assert response.status_code == 401
|
||||
assert response.headers["WWW-Authenticate"] == BEARER
|
||||
await cache.aclose()
|
||||
|
||||
|
||||
async def test_fill_racing_with_logout_does_not_revive_token(valkey: dict[str, str]) -> None:
|
||||
async with running_app(cache_url=valkey["url"]) as http:
|
||||
alice = await register(http, "alice")
|
||||
directory = await resolve(http, SessionDirectory)
|
||||
assert isinstance(directory, CachedSessionDirectory)
|
||||
origin = directory._origin
|
||||
stale: list[Session | None] = []
|
||||
entered, released = asyncio.Event(), asyncio.Event()
|
||||
|
||||
class SlowOrigin:
|
||||
async def find(self, token_hash: bytes, now: datetime) -> Session | None:
|
||||
stale.append(await origin.find(token_hash, now))
|
||||
entered.set()
|
||||
await released.wait()
|
||||
return stale[-1]
|
||||
|
||||
async def invalidate(self, session: Session) -> None:
|
||||
await origin.invalidate(session)
|
||||
|
||||
directory._origin = SlowOrigin()
|
||||
reader = asyncio.create_task(http.get("/api/v1/users/me", headers=actor(alice)))
|
||||
await entered.wait()
|
||||
directory._origin = origin
|
||||
assert (
|
||||
await http.delete("/api/v1/auth/sessions/current", headers=actor(alice))
|
||||
).status_code == 204
|
||||
released.set()
|
||||
assert (await reader).status_code == 200
|
||||
assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 401
|
||||
|
||||
|
||||
async def test_flushall_loses_nothing(valkey: dict[str, str]) -> None:
|
||||
cache = Redis.from_url(valkey["url"])
|
||||
async with running_app(cache_url=valkey["url"]) as http:
|
||||
alice = await register(http, "alice")
|
||||
bob = await register(http, "bob")
|
||||
assert (
|
||||
await http.delete("/api/v1/auth/sessions/current", headers=actor(bob))
|
||||
).status_code == 204
|
||||
await cache.flushall()
|
||||
assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200
|
||||
assert (await http.get("/api/v1/users/me", headers=actor(bob))).status_code == 401
|
||||
await cache.aclose()
|
||||
|
||||
|
||||
async def test_unreachable_cache_is_bypassed_without_anonymous_access() -> None:
|
||||
async with running_app(cache_url="redis://127.0.0.1:1/0") as http:
|
||||
alice = await register(http, "alice")
|
||||
started = time.perf_counter()
|
||||
me = await http.get("/api/v1/users/me", headers=actor(alice))
|
||||
stranger = await http.get("/api/v1/users/me", headers=bearer("x" * 43))
|
||||
elapsed = time.perf_counter() - started
|
||||
ready = await http.get("/health/ready")
|
||||
logout = await http.delete("/api/v1/auth/sessions/current", headers=actor(alice))
|
||||
still = await http.get("/api/v1/users/me", headers=actor(alice))
|
||||
assert me.json() == alice
|
||||
assert stranger.status_code == 401
|
||||
assert stranger.headers["WWW-Authenticate"] == BEARER
|
||||
assert elapsed < 1
|
||||
assert ready.status_code == 200
|
||||
assert logout.status_code == 503
|
||||
assert logout.json()["error"]["code"] == "unavailable"
|
||||
assert still.status_code == 200
|
||||
@@ -0,0 +1,88 @@
|
||||
import asyncio
|
||||
from urllib.parse import quote
|
||||
from uuid import uuid4
|
||||
|
||||
from httpx import AsyncClient
|
||||
|
||||
from conftest import PASSWORD, actor, make_chat, register
|
||||
|
||||
CLIENTS = 10
|
||||
PER_CLIENT = 10
|
||||
TOTAL = CLIENTS * PER_CLIENT
|
||||
|
||||
|
||||
async def drain(client: AsyncClient, chat: dict, reader: dict) -> list[dict]:
|
||||
collected: list[dict] = []
|
||||
cursor: str | None = None
|
||||
while True:
|
||||
query = "?limit=100" + (f"&cursor={quote(cursor, safe='')}" if cursor else "")
|
||||
page = (
|
||||
await client.get(f"/api/v1/chats/{chat['id']}/messages{query}", headers=actor(reader))
|
||||
).json()
|
||||
collected.extend(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
return collected
|
||||
|
||||
|
||||
async def flood(client: AsyncClient, chat: dict, sender: dict) -> list[int]:
|
||||
async def writer(worker: int) -> list[int]:
|
||||
codes = []
|
||||
for index in range(PER_CLIENT):
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": f"нагрузка-{worker}-{index}"},
|
||||
headers=actor(sender),
|
||||
)
|
||||
codes.append(response.status_code)
|
||||
return codes
|
||||
|
||||
batches = await asyncio.gather(*(writer(worker) for worker in range(CLIENTS)))
|
||||
return [code for batch in batches for code in batch]
|
||||
|
||||
|
||||
async def test_hundred_messages_from_ten_clients(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
|
||||
codes = await flood(client, chat, alice)
|
||||
assert codes.count(201) == TOTAL, f"неуспешные ответы: {set(codes) - {201}}"
|
||||
|
||||
history = await drain(client, chat, bob)
|
||||
assert len(history) == TOTAL
|
||||
assert len({item["id"] for item in history}) == TOTAL
|
||||
assert len({item["text"] for item in history}) == TOTAL
|
||||
|
||||
keys = [(item["created_at"], item["id"]) for item in history]
|
||||
assert keys == sorted(keys), "история не упорядочена по (created_at, id)"
|
||||
stamps = [item["created_at"] for item in history]
|
||||
assert len(set(stamps)) == TOTAL, "created_at внутри чата обязан строго возрастать"
|
||||
|
||||
|
||||
async def test_parallel_registration_keeps_username_unique(client: AsyncClient) -> None:
|
||||
body = {"username": f"race_{uuid4().hex[:12]}", "display_name": "Гонка", "password": PASSWORD}
|
||||
responses = await asyncio.gather(*(client.post("/api/v1/users", json=body) for _ in range(20)))
|
||||
codes = [response.status_code for response in responses]
|
||||
assert codes.count(201) == 1
|
||||
assert codes.count(409) == len(codes) - 1
|
||||
|
||||
|
||||
async def test_parallel_chat_creation_is_atomic(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
responses = await asyncio.gather(
|
||||
*(
|
||||
client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": f"Чат {index}", "member_ids": [alice["id"], bob["id"]]},
|
||||
headers=actor(alice),
|
||||
)
|
||||
for index in range(20)
|
||||
)
|
||||
)
|
||||
assert all(response.status_code == 201 for response in responses)
|
||||
listed = (await client.get("/api/v1/chats?limit=100", headers=actor(bob))).json()
|
||||
assert len(listed["items"]) == 20
|
||||
keys = [(item["created_at"], item["id"]) for item in listed["items"]]
|
||||
assert keys == sorted(keys)
|
||||
@@ -0,0 +1,188 @@
|
||||
import asyncio
|
||||
from urllib.parse import quote
|
||||
from uuid import uuid4
|
||||
|
||||
from httpx import AsyncClient
|
||||
|
||||
from conftest import PASSWORD, actor, make_chat, new_user, register, running_app, scalar
|
||||
|
||||
REGISTRATIONS = 25
|
||||
|
||||
|
||||
async def drain_history(client: AsyncClient, chat: dict, reader: dict) -> list[dict]:
|
||||
collected: list[dict] = []
|
||||
cursor: str | None = None
|
||||
while True:
|
||||
query = "?limit=100" + (f"&cursor={quote(cursor, safe='')}" if cursor else "")
|
||||
page = (
|
||||
await client.get(f"/api/v1/chats/{chat['id']}/messages{query}", headers=actor(reader))
|
||||
).json()
|
||||
collected.extend(page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
return collected
|
||||
|
||||
|
||||
async def test_registration_is_visible_to_chats_immediately() -> None:
|
||||
async with running_app() as client:
|
||||
for _ in range(REGISTRATIONS):
|
||||
user = await register(client, "race")
|
||||
response = await client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": "Сразу после регистрации", "member_ids": [user["id"]]},
|
||||
headers=actor(user),
|
||||
)
|
||||
assert response.status_code == 201, response.text
|
||||
|
||||
|
||||
async def test_parallel_registrations_are_all_usable_as_members() -> None:
|
||||
async with running_app() as client:
|
||||
alice = await register(client, "alice")
|
||||
bodies = [new_user(f"par{index}") for index in range(REGISTRATIONS)]
|
||||
responses = await asyncio.gather(
|
||||
*(client.post("/api/v1/users", json=body) for body in bodies)
|
||||
)
|
||||
assert all(response.status_code == 201 for response in responses)
|
||||
created = [response.json()["id"] for response in responses]
|
||||
chat = await client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": "Все параллельные", "member_ids": [alice["id"], *created]},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert chat.status_code == 201, chat.text
|
||||
assert len(chat.json()["member_ids"]) == REGISTRATIONS + 1
|
||||
|
||||
|
||||
async def test_rejected_registration_leaves_no_trace() -> None:
|
||||
async with running_app() as client:
|
||||
alice = await register(client, "alice")
|
||||
duplicate = await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": alice["username"], "display_name": "Двойник", "password": PASSWORD},
|
||||
)
|
||||
assert duplicate.status_code == 409
|
||||
invalid = await client.post(
|
||||
"/api/v1/users", json={"username": "AB", "display_name": "", "password": PASSWORD}
|
||||
)
|
||||
assert invalid.status_code == 400
|
||||
sql = "SELECT count(*) FROM users WHERE username = $1"
|
||||
assert await scalar(sql, alice["username"]) == 1
|
||||
|
||||
|
||||
async def test_failed_chat_creation_rolls_back_both_tables() -> None:
|
||||
title = f"Откат {uuid4().hex}"
|
||||
async with running_app() as client:
|
||||
alice = await register(client, "alice")
|
||||
before = (await client.get("/api/v1/chats?limit=100", headers=actor(alice))).json()
|
||||
rejected = await client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": title, "member_ids": [alice["id"], str(uuid4())]},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert rejected.status_code == 400
|
||||
assert rejected.json()["error"]["code"] == "invalid_request"
|
||||
after = (await client.get("/api/v1/chats?limit=100", headers=actor(alice))).json()
|
||||
assert after["items"] == before["items"]
|
||||
assert await scalar("SELECT count(*) FROM chats WHERE title = $1", title) == 0
|
||||
members = "SELECT count(*) FROM chat_members WHERE user_id = $1::uuid"
|
||||
assert await scalar(members, alice["id"]) == 0
|
||||
|
||||
|
||||
async def test_rejected_message_does_not_enter_history() -> None:
|
||||
async with running_app() as client:
|
||||
alice = await register(client, "alice")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice)
|
||||
|
||||
assert (
|
||||
await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": " "},
|
||||
headers=actor(alice),
|
||||
)
|
||||
).status_code == 400
|
||||
assert (
|
||||
await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": "чужое"},
|
||||
headers=actor(eve),
|
||||
)
|
||||
).status_code == 404
|
||||
|
||||
assert await drain_history(client, chat, alice) == []
|
||||
|
||||
|
||||
async def test_confirmed_write_is_visible_to_next_read() -> None:
|
||||
async with running_app() as client:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
|
||||
for index in range(30):
|
||||
posted = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": f"подтверждение {index}"},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert posted.status_code == 201
|
||||
history = await drain_history(client, chat, bob)
|
||||
assert history[-1]["id"] == posted.json()["id"]
|
||||
assert len(history) == index + 1
|
||||
|
||||
|
||||
async def test_parallel_writes_across_zones_keep_counts_consistent() -> None:
|
||||
async with running_app() as client:
|
||||
alice = await register(client, "alice")
|
||||
chats = [await make_chat(client, alice) for _ in range(4)]
|
||||
|
||||
async def writer(chat: dict, worker: int) -> None:
|
||||
for index in range(10):
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": f"поток-{worker}-{index}"},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert response.status_code == 201
|
||||
|
||||
async def registrar(index: int) -> str:
|
||||
return (await register(client, f"parallel{index}"))["id"]
|
||||
|
||||
results = await asyncio.gather(
|
||||
*(writer(chat, number) for number, chat in enumerate(chats)),
|
||||
*(registrar(index) for index in range(10)),
|
||||
)
|
||||
|
||||
registered = [item for item in results if isinstance(item, str)]
|
||||
assert len(set(registered)) == 10
|
||||
for chat in chats:
|
||||
history = await drain_history(client, chat, alice)
|
||||
assert len(history) == 10
|
||||
assert len({item["id"] for item in history}) == 10
|
||||
keys = [(item["created_at"], item["id"]) for item in history]
|
||||
assert keys == sorted(keys)
|
||||
|
||||
|
||||
async def test_chat_membership_survives_parallel_reads_and_writes() -> None:
|
||||
async with running_app() as client:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
eve = await register(client, "eve")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
|
||||
async def write(index: int) -> None:
|
||||
await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": f"параллельно {index}"},
|
||||
headers=actor(alice),
|
||||
)
|
||||
|
||||
async def intruder() -> int:
|
||||
response = await client.get(f"/api/v1/chats/{chat['id']}/messages", headers=actor(eve))
|
||||
return response.status_code
|
||||
|
||||
results = await asyncio.gather(
|
||||
*(write(index) for index in range(20)),
|
||||
*(intruder() for _ in range(20)),
|
||||
)
|
||||
assert {code for code in results if isinstance(code, int)} == {404}
|
||||
assert len(await drain_history(client, chat, bob)) == 20
|
||||
@@ -0,0 +1,124 @@
|
||||
import asyncio
|
||||
from dataclasses import fields
|
||||
from datetime import UTC, datetime
|
||||
from uuid import uuid4
|
||||
|
||||
from httpx import ASGITransport, AsyncClient
|
||||
|
||||
from conftest import actor, make_chat, register, split_settings
|
||||
from fakes import NullLogger
|
||||
from messenger.identity.domain.events import UserRegistered
|
||||
from messenger.main import create_app
|
||||
from messenger.messaging.domain.events import MessagePosted
|
||||
from messenger.shared.application.messagebus import EventBus, InMemoryEventPublisher
|
||||
|
||||
|
||||
def posted() -> MessagePosted:
|
||||
return MessagePosted(
|
||||
message_id=uuid4(),
|
||||
chat_id=uuid4(),
|
||||
sender_id=uuid4(),
|
||||
text_length=5,
|
||||
created_at=datetime.now(UTC),
|
||||
)
|
||||
|
||||
|
||||
async def test_event_has_no_message_text() -> None:
|
||||
names = {field.name for field in fields(posted())}
|
||||
assert names == {"name", "message_id", "chat_id", "sender_id", "text_length", "created_at"}
|
||||
|
||||
|
||||
async def test_every_subscriber_receives_event() -> None:
|
||||
bus = EventBus(NullLogger())
|
||||
seen: list[str] = []
|
||||
|
||||
async def first(_event: MessagePosted) -> None:
|
||||
seen.append("first")
|
||||
|
||||
async def second(_event: MessagePosted) -> None:
|
||||
seen.append("second")
|
||||
|
||||
bus.subscribe(MessagePosted, first)
|
||||
bus.subscribe(MessagePosted, second)
|
||||
bus.start()
|
||||
await InMemoryEventPublisher(bus).publish([posted()])
|
||||
await bus.stop()
|
||||
assert sorted(seen) == ["first", "second"]
|
||||
|
||||
|
||||
async def test_failing_subscriber_does_not_block_others() -> None:
|
||||
bus = EventBus(NullLogger())
|
||||
survived: list[str] = []
|
||||
|
||||
async def broken(_event: MessagePosted) -> None:
|
||||
raise RuntimeError("обработчик упал")
|
||||
|
||||
async def healthy(_event: MessagePosted) -> None:
|
||||
survived.append("ok")
|
||||
|
||||
bus.subscribe(MessagePosted, broken)
|
||||
bus.subscribe(MessagePosted, healthy)
|
||||
bus.start()
|
||||
await InMemoryEventPublisher(bus).publish([posted()])
|
||||
await bus.stop()
|
||||
assert survived == ["ok"]
|
||||
|
||||
|
||||
async def test_queue_overflow_drops_events_without_raising() -> None:
|
||||
bus = EventBus(NullLogger(), max_queue=16)
|
||||
|
||||
async def never_called(_event: MessagePosted) -> None:
|
||||
raise AssertionError("обработчик не должен вызываться без запущенной шины")
|
||||
|
||||
bus.subscribe(MessagePosted, never_called)
|
||||
publisher = InMemoryEventPublisher(bus)
|
||||
await publisher.publish([posted() for _ in range(64)])
|
||||
assert bus.dropped > 0
|
||||
assert bus.pending <= 16
|
||||
|
||||
|
||||
async def test_projection_runs_before_publish_returns() -> None:
|
||||
bus = EventBus(NullLogger())
|
||||
seen: list[str] = []
|
||||
|
||||
async def projection(_event: MessagePosted) -> None:
|
||||
seen.append("projected")
|
||||
|
||||
bus.project(MessagePosted, projection)
|
||||
await InMemoryEventPublisher(bus).publish([posted()])
|
||||
assert seen == ["projected"]
|
||||
|
||||
|
||||
async def test_publication_does_not_delay_response() -> None:
|
||||
app = create_app(**split_settings(log_level="CRITICAL"))
|
||||
async with (
|
||||
app.router.lifespan_context(app),
|
||||
AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as http,
|
||||
):
|
||||
alice = await register(http, "alice")
|
||||
chat = await make_chat(http, alice)
|
||||
bus = await app.state.dishka_container.get(EventBus)
|
||||
slow = asyncio.Event()
|
||||
|
||||
async def blocker(_event: MessagePosted) -> None:
|
||||
await slow.wait()
|
||||
|
||||
bus.subscribe(MessagePosted, blocker)
|
||||
response = await asyncio.wait_for(
|
||||
http.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": "не ждём обработчик"},
|
||||
headers=actor(alice),
|
||||
),
|
||||
timeout=2,
|
||||
)
|
||||
assert response.status_code == 201
|
||||
slow.set()
|
||||
|
||||
|
||||
async def test_null_logger_hides_everything() -> None:
|
||||
logger = NullLogger()
|
||||
logger.info("x", route="/")
|
||||
logger.warning("x")
|
||||
logger.error("x")
|
||||
assert isinstance(UserRegistered, type)
|
||||
@@ -0,0 +1,63 @@
|
||||
import asyncpg
|
||||
import pytest
|
||||
|
||||
from conftest import DATABASE, scalar
|
||||
from messenger.migrate import MigrationChangedError, migrate, migrations
|
||||
|
||||
COUNTS = """
|
||||
SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM sessions),
|
||||
(SELECT count(*) FROM chats), (SELECT count(*) FROM chat_members),
|
||||
(SELECT count(*) FROM messages)
|
||||
"""
|
||||
|
||||
|
||||
async def counts() -> list[int]:
|
||||
connection = await asyncpg.connect(DATABASE["url"])
|
||||
try:
|
||||
return list(await connection.fetchrow(COUNTS))
|
||||
finally:
|
||||
await connection.close()
|
||||
|
||||
|
||||
async def test_migrations_are_ordered_and_versioned() -> None:
|
||||
versions = [version for version, _ in migrations()]
|
||||
assert versions == sorted(versions)
|
||||
assert versions[0] == "0001_init"
|
||||
applied = await scalar("SELECT array_agg(version ORDER BY version) FROM schema_migrations")
|
||||
assert applied == versions
|
||||
|
||||
|
||||
async def test_rerun_changes_nothing() -> None:
|
||||
before = await counts()
|
||||
assert await migrate(DATABASE["url"]) == []
|
||||
assert await counts() == before
|
||||
|
||||
|
||||
async def test_changed_migration_is_refused() -> None:
|
||||
connection = await asyncpg.connect(DATABASE["url"])
|
||||
try:
|
||||
original = await connection.fetchval(
|
||||
"SELECT checksum FROM schema_migrations WHERE version = '0001_init'"
|
||||
)
|
||||
await connection.execute(
|
||||
"UPDATE schema_migrations SET checksum = 'tampered' WHERE version = '0001_init'"
|
||||
)
|
||||
with pytest.raises(MigrationChangedError):
|
||||
await migrate(DATABASE["url"])
|
||||
await connection.execute(
|
||||
"UPDATE schema_migrations SET checksum = $1 WHERE version = '0001_init'", original
|
||||
)
|
||||
finally:
|
||||
await connection.close()
|
||||
|
||||
|
||||
async def test_sender_must_be_member_even_bypassing_api() -> None:
|
||||
connection = await asyncpg.connect(DATABASE["url"])
|
||||
try:
|
||||
with pytest.raises(asyncpg.ForeignKeyViolationError):
|
||||
await connection.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
|
||||
"VALUES (gen_random_uuid(), gen_random_uuid(), gen_random_uuid(), 'x', now())"
|
||||
)
|
||||
finally:
|
||||
await connection.close()
|
||||
@@ -0,0 +1,196 @@
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
from httpx import AsyncClient
|
||||
|
||||
from conftest import PASSWORD, actor, make_chat, register
|
||||
|
||||
ERROR_CODES = {
|
||||
400: "invalid_request",
|
||||
401: "unauthorized",
|
||||
404: "not_found",
|
||||
409: "conflict",
|
||||
}
|
||||
|
||||
|
||||
def assert_error(response, expected_status: int) -> None:
|
||||
assert response.status_code == expected_status, response.text
|
||||
assert response.headers.get("content-type", "").startswith("application/json")
|
||||
body = response.json()
|
||||
assert set(body) == {"error"}
|
||||
assert set(body["error"]) == {"code", "message", "request_id"}
|
||||
assert body["error"]["code"] == ERROR_CODES[expected_status]
|
||||
assert body["error"]["message"]
|
||||
assert body["error"]["request_id"] == response.headers["X-Request-Id"]
|
||||
|
||||
|
||||
async def test_malformed_json(client: AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/api/v1/users",
|
||||
content=b'{"username": ',
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
async def test_unexpected_field(client: AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": "abc_def", "display_name": "X", "password": PASSWORD, "role": "admin"},
|
||||
)
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
async def test_wrong_types(client: AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/api/v1/users", json={"username": 1, "display_name": True, "password": 12345678901234}
|
||||
)
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body",
|
||||
[
|
||||
{"username": "Alice", "display_name": "X", "password": PASSWORD},
|
||||
{"username": "ab", "display_name": "X", "password": PASSWORD},
|
||||
{"username": "alice_01\n", "display_name": "X", "password": PASSWORD},
|
||||
{"username": "abc_def", "display_name": "", "password": PASSWORD},
|
||||
{"username": "abc_def", "display_name": " ", "password": PASSWORD},
|
||||
{"username": "abc_def", "display_name": "x" * 101, "password": PASSWORD},
|
||||
{"username": "abc_def", "display_name": "X", "password": "short"},
|
||||
{"username": "abc_def", "display_name": "X", "password": "x" * 129},
|
||||
{"username": "abc_def", "display_name": "X", "password": " " * 20},
|
||||
{"username": "abc_def", "display_name": "X"},
|
||||
{"username": "abc_def", "password": PASSWORD},
|
||||
],
|
||||
)
|
||||
async def test_invalid_registration(client: AsyncClient, body: dict) -> None:
|
||||
assert_error(await client.post("/api/v1/users", json=body), 400)
|
||||
|
||||
|
||||
async def test_duplicate_username(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
repeat = await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": alice["username"], "display_name": "Другая", "password": PASSWORD},
|
||||
)
|
||||
assert_error(repeat, 409)
|
||||
|
||||
|
||||
async def test_missing_identity(client: AsyncClient) -> None:
|
||||
assert_error(await client.get("/api/v1/users/me"), 401)
|
||||
|
||||
|
||||
BAD_AUTHORIZATIONS = [
|
||||
"",
|
||||
"Bearer",
|
||||
"Bearer ",
|
||||
"Bearer not a token",
|
||||
"Bearer " + "x" * 43,
|
||||
"Token abcdef",
|
||||
"11111111-1111-4111-8111-111111111111",
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("raw", BAD_AUTHORIZATIONS)
|
||||
async def test_invalid_bearer(client: AsyncClient, raw: str) -> None:
|
||||
response = await client.get("/api/v1/users/me", headers={"Authorization": raw})
|
||||
assert_error(response, 401)
|
||||
assert response.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
async def test_user_id_header_alone_is_ignored(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
response = await client.get("/api/v1/users/me", headers={"X-User-Id": alice["id"]})
|
||||
assert_error(response, 401)
|
||||
|
||||
|
||||
async def test_identity_checked_before_body(client: AsyncClient) -> None:
|
||||
response = await client.post(
|
||||
"/api/v1/chats",
|
||||
content=b"{broken",
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
assert_error(response, 401)
|
||||
|
||||
|
||||
async def test_empty_message_rejected(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
for text in ("", " ", "\n\t"):
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": text},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
async def test_long_message_rejected(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
chat = await make_chat(client, alice)
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": "я" * 4001},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
async def test_sender_id_not_accepted(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": "подмена", "sender_id": bob["id"]},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body",
|
||||
[
|
||||
{"title": "Чат", "member_ids": []},
|
||||
{"title": "", "member_ids": None},
|
||||
{"title": " ", "member_ids": None},
|
||||
{"title": "Чат", "member_ids": ["не-uuid"]},
|
||||
{"title": "Чат", "member_ids": [1]},
|
||||
{"title": "Чат", "member_ids": "не-список"},
|
||||
],
|
||||
)
|
||||
async def test_invalid_chat_creation(client: AsyncClient, body: dict) -> None:
|
||||
alice = await register(client, "alice")
|
||||
payload = dict(body)
|
||||
if payload["member_ids"] is None:
|
||||
payload["member_ids"] = [alice["id"]]
|
||||
response = await client.post("/api/v1/chats", json=payload, headers=actor(alice))
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
async def test_creator_must_be_member(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
response = await client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": "Чат", "member_ids": [bob["id"]]},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
async def test_unknown_member_rejected(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
response = await client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": "Чат", "member_ids": [alice["id"], str(uuid4())]},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert_error(response, 400)
|
||||
|
||||
|
||||
async def test_bad_chat_id_in_path(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
assert_error(await client.get("/api/v1/chats/не-uuid", headers=actor(alice)), 400)
|
||||
@@ -0,0 +1,144 @@
|
||||
import json
|
||||
import time
|
||||
from uuid import uuid4
|
||||
|
||||
from httpx import ASGITransport, AsyncClient
|
||||
|
||||
from conftest import PASSWORD, actor, make_chat, register, running_app, split_settings
|
||||
from messenger.main import create_app
|
||||
|
||||
MARKER_TEXT = "маркер-который-не-должен-попасть-в-логи-9f3a"
|
||||
|
||||
|
||||
async def test_health_needs_no_identity(client: AsyncClient) -> None:
|
||||
for path in ("/health/live", "/health/ready"):
|
||||
response = await client.get(path)
|
||||
assert response.status_code == 200
|
||||
assert response.json() == {"status": "ok"}
|
||||
assert response.headers["X-Request-Id"]
|
||||
|
||||
|
||||
async def test_every_response_carries_request_id(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
probes = [
|
||||
await client.get("/health/live"),
|
||||
await client.get("/api/v1/users/me", headers=actor(alice)),
|
||||
await client.get("/api/v1/users/me"),
|
||||
await client.get(f"/api/v1/chats/{uuid4()}", headers=actor(alice)),
|
||||
await client.get("/api/v1/unknown-path"),
|
||||
]
|
||||
assert all(probe.headers.get("X-Request-Id") for probe in probes)
|
||||
|
||||
|
||||
async def test_client_request_id_is_preserved(client: AsyncClient) -> None:
|
||||
response = await client.get("/health/live", headers={"X-Request-Id": "trace-42"})
|
||||
assert response.headers["X-Request-Id"] == "trace-42"
|
||||
|
||||
|
||||
async def test_unknown_public_route_is_404(client: AsyncClient) -> None:
|
||||
response = await client.get("/nothing-here")
|
||||
assert response.status_code == 404
|
||||
assert response.json()["error"]["code"] == "not_found"
|
||||
|
||||
|
||||
async def test_unknown_protected_route_needs_identity(client: AsyncClient) -> None:
|
||||
anonymous = await client.get("/api/v1/unknown-path")
|
||||
assert anonymous.status_code == 401
|
||||
assert set(anonymous.json()["error"]) == {"code", "message", "request_id"}
|
||||
alice = await register(client, "alice")
|
||||
identified = await client.get("/api/v1/unknown-path", headers=actor(alice))
|
||||
assert identified.status_code == 404
|
||||
|
||||
|
||||
async def test_method_not_allowed_is_hidden(client: AsyncClient) -> None:
|
||||
response = await client.delete("/health/live")
|
||||
assert response.status_code == 404
|
||||
assert response.json()["error"]["code"] == "not_found"
|
||||
|
||||
|
||||
async def test_logs_do_not_contain_message_text(capsys) -> None:
|
||||
app = create_app(**split_settings(log_level="INFO"))
|
||||
async with (
|
||||
app.router.lifespan_context(app),
|
||||
AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as http,
|
||||
):
|
||||
alice = await register(http, "alice")
|
||||
chat = await make_chat(http, alice)
|
||||
response = await http.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": MARKER_TEXT},
|
||||
headers=actor(alice),
|
||||
)
|
||||
assert response.status_code == 201
|
||||
captured = capsys.readouterr()
|
||||
assert MARKER_TEXT not in captured.out
|
||||
assert MARKER_TEXT not in captured.err
|
||||
assert alice["display_name"] not in captured.out
|
||||
assert any("request.handled" in line for line in captured.out.splitlines())
|
||||
|
||||
|
||||
async def test_log_lines_are_json(capsys) -> None:
|
||||
app = create_app(**split_settings(log_level="INFO"))
|
||||
async with (
|
||||
app.router.lifespan_context(app),
|
||||
AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as http,
|
||||
):
|
||||
await http.get("/health/live")
|
||||
for line in capsys.readouterr().out.splitlines():
|
||||
record = json.loads(line)
|
||||
assert {"ts", "level", "event"} <= set(record)
|
||||
|
||||
|
||||
async def test_body_limit_returns_413() -> None:
|
||||
app = create_app(**split_settings(max_body_bytes=4096))
|
||||
async with (
|
||||
app.router.lifespan_context(app),
|
||||
AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as http,
|
||||
):
|
||||
response = await http.post("/api/v1/users", content=b"x" * 5000)
|
||||
assert response.status_code == 413
|
||||
assert response.json()["error"]["code"] == "payload_too_large"
|
||||
|
||||
|
||||
async def test_ready_turns_unavailable_without_database() -> None:
|
||||
async with running_app(database_url="postgresql://u:p@127.0.0.1:1/none") as http:
|
||||
started = time.perf_counter()
|
||||
ready = await http.get("/health/ready")
|
||||
live = await http.get("/health/live")
|
||||
elapsed = time.perf_counter() - started
|
||||
assert ready.status_code == 503
|
||||
assert ready.json()["error"]["code"] == "unavailable"
|
||||
assert live.status_code == 200
|
||||
assert elapsed < 2
|
||||
|
||||
|
||||
async def test_protected_request_is_503_not_401_without_database() -> None:
|
||||
async with running_app(database_url="postgresql://u:p@127.0.0.1:1/none") as http:
|
||||
response = await http.get(
|
||||
"/api/v1/users/me", headers={"Authorization": "Bearer " + "x" * 43}
|
||||
)
|
||||
assert response.status_code == 503
|
||||
assert response.json()["error"]["code"] == "unavailable"
|
||||
assert response.json()["error"]["request_id"] == response.headers["X-Request-Id"]
|
||||
|
||||
|
||||
async def test_state_survives_new_process() -> None:
|
||||
async with running_app() as http:
|
||||
alice = await register(http, "alice")
|
||||
chat = await make_chat(http, alice)
|
||||
async with running_app() as http:
|
||||
me = await http.get("/api/v1/users/me", headers=actor(alice))
|
||||
listed = await http.get("/api/v1/chats?limit=100", headers=actor(alice))
|
||||
assert me.json() == alice
|
||||
assert [item["id"] for item in listed.json()["items"]] == [chat["id"]]
|
||||
|
||||
|
||||
async def test_logs_do_not_contain_credentials(capsys) -> None:
|
||||
async with running_app(log_level="INFO") as http:
|
||||
alice = await register(http, "secret")
|
||||
assert (await http.get("/api/v1/users/me", headers=actor(alice))).status_code == 200
|
||||
output = capsys.readouterr()
|
||||
captured = output.out + output.err
|
||||
assert PASSWORD not in captured
|
||||
assert actor(alice)["Authorization"].split()[1] not in captured
|
||||
assert "audit.session_opened" in captured
|
||||
@@ -0,0 +1,155 @@
|
||||
from urllib.parse import quote
|
||||
|
||||
import pytest
|
||||
from httpx import AsyncClient
|
||||
|
||||
from conftest import actor, make_chat, register
|
||||
|
||||
TOTAL = 12
|
||||
|
||||
|
||||
async def fill(client: AsyncClient, chat: dict, sender: dict, count: int) -> list[str]:
|
||||
texts = []
|
||||
for index in range(count):
|
||||
text = f"сообщение {index:02d}"
|
||||
response = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": text},
|
||||
headers=actor(sender),
|
||||
)
|
||||
assert response.status_code == 201, response.text
|
||||
texts.append(text)
|
||||
return texts
|
||||
|
||||
|
||||
async def walk(client: AsyncClient, chat: dict, reader: dict, limits: list[int]) -> list[str]:
|
||||
collected: list[str] = []
|
||||
cursor: str | None = None
|
||||
step = 0
|
||||
while True:
|
||||
limit = limits[min(step, len(limits) - 1)]
|
||||
query = f"?limit={limit}"
|
||||
if cursor:
|
||||
query += f"&cursor={quote(cursor, safe='')}"
|
||||
response = await client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages{query}", headers=actor(reader)
|
||||
)
|
||||
assert response.status_code == 200, response.text
|
||||
page = response.json()
|
||||
assert len(page["items"]) <= limit
|
||||
collected.extend(item["text"] for item in page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
step += 1
|
||||
if cursor is None:
|
||||
return collected
|
||||
|
||||
|
||||
async def test_full_walk_has_no_gaps_or_repeats(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
expected = await fill(client, chat, alice, TOTAL)
|
||||
assert await walk(client, chat, bob, [5]) == expected
|
||||
|
||||
|
||||
async def test_limit_may_change_between_pages(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
chat = await make_chat(client, alice)
|
||||
expected = await fill(client, chat, alice, TOTAL)
|
||||
assert await walk(client, chat, alice, [1, 7, 3, 100]) == expected
|
||||
|
||||
|
||||
async def test_last_page_closes_history(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
chat = await make_chat(client, alice)
|
||||
await fill(client, chat, alice, 2)
|
||||
first = (
|
||||
await client.get(f"/api/v1/chats/{chat['id']}/messages?limit=2", headers=actor(alice))
|
||||
).json()
|
||||
assert len(first["items"]) == 2
|
||||
assert first["next_cursor"] is None
|
||||
|
||||
|
||||
async def test_cursor_is_shared_between_members(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
bob = await register(client, "bob")
|
||||
chat = await make_chat(client, alice, bob)
|
||||
await fill(client, chat, alice, 3)
|
||||
page = (
|
||||
await client.get(f"/api/v1/chats/{chat['id']}/messages?limit=1", headers=actor(alice))
|
||||
).json()
|
||||
cursor = quote(page["next_cursor"], safe="")
|
||||
response = await client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?limit=1&cursor={cursor}", headers=actor(bob)
|
||||
)
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
async def test_cursor_from_another_chat_is_rejected(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
first = await make_chat(client, alice)
|
||||
second = await make_chat(client, alice)
|
||||
await fill(client, first, alice, 3)
|
||||
await fill(client, second, alice, 3)
|
||||
page = (
|
||||
await client.get(f"/api/v1/chats/{first['id']}/messages?limit=1", headers=actor(alice))
|
||||
).json()
|
||||
cursor = quote(page["next_cursor"], safe="")
|
||||
response = await client.get(
|
||||
f"/api/v1/chats/{second['id']}/messages?limit=1&cursor={cursor}", headers=actor(alice)
|
||||
)
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("cursor", ["garbage", "1.2.3.4", "%20"])
|
||||
async def test_broken_cursor_is_rejected(client: AsyncClient, cursor: str) -> None:
|
||||
alice = await register(client, "alice")
|
||||
chat = await make_chat(client, alice)
|
||||
response = await client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?cursor={cursor}", headers=actor(alice)
|
||||
)
|
||||
assert response.status_code == 400
|
||||
|
||||
|
||||
@pytest.mark.parametrize("limit", ["0", "-1", "101", "abc", "1.5", ""])
|
||||
async def test_limit_out_of_range(client: AsyncClient, limit: str) -> None:
|
||||
alice = await register(client, "alice")
|
||||
chat = await make_chat(client, alice)
|
||||
for path in (f"/api/v1/chats/{chat['id']}/messages", "/api/v1/chats"):
|
||||
response = await client.get(f"{path}?limit={limit}", headers=actor(alice))
|
||||
assert response.status_code == 400, f"{path}?limit={limit} → {response.status_code}"
|
||||
|
||||
|
||||
async def test_default_limit_is_50(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
chat = await make_chat(client, alice)
|
||||
await fill(client, chat, alice, 51)
|
||||
page = (await client.get(f"/api/v1/chats/{chat['id']}/messages", headers=actor(alice))).json()
|
||||
assert len(page["items"]) == 50
|
||||
assert page["next_cursor"] is not None
|
||||
|
||||
|
||||
async def test_unknown_query_parameter_is_ignored(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
chat = await make_chat(client, alice)
|
||||
await fill(client, chat, alice, 2)
|
||||
for path in (f"/api/v1/chats/{chat['id']}/messages", "/api/v1/chats"):
|
||||
response = await client.get(f"{path}?limit=1&unknown=x", headers=actor(alice))
|
||||
assert response.status_code == 200, response.text
|
||||
assert len(response.json()["items"]) == 1
|
||||
|
||||
|
||||
async def test_chat_list_pagination(client: AsyncClient) -> None:
|
||||
alice = await register(client, "alice")
|
||||
created = [(await make_chat(client, alice))["id"] for _ in range(5)]
|
||||
collected: list[str] = []
|
||||
cursor: str | None = None
|
||||
while True:
|
||||
query = "?limit=2" + (f"&cursor={quote(cursor, safe='')}" if cursor else "")
|
||||
page = (await client.get(f"/api/v1/chats{query}", headers=actor(alice))).json()
|
||||
collected.extend(item["id"] for item in page["items"])
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
assert collected == created
|
||||
@@ -0,0 +1,27 @@
|
||||
import time
|
||||
|
||||
from conftest import actor, register, resolve, running_app
|
||||
from messenger.shared.infrastructure.postgres import Database
|
||||
|
||||
|
||||
async def test_exhausted_pool_answers_503_in_bounded_time() -> None:
|
||||
async with running_app(db_pool_max_size=1, db_acquire_timeout_seconds=0.3) as http:
|
||||
alice = await register(http, "alice")
|
||||
database = await resolve(http, Database)
|
||||
async with database.connection():
|
||||
started = time.perf_counter()
|
||||
starved = await http.get("/api/v1/users/me", headers=actor(alice))
|
||||
elapsed = time.perf_counter() - started
|
||||
recovered = await http.get("/api/v1/users/me", headers=actor(alice))
|
||||
assert starved.status_code == 503
|
||||
assert starved.json()["error"]["code"] == "unavailable"
|
||||
assert 0.25 < elapsed < 1
|
||||
assert recovered.json() == alice
|
||||
|
||||
|
||||
async def test_statement_timeout_is_set_on_connections() -> None:
|
||||
async with running_app(db_command_timeout_seconds=1.5) as http:
|
||||
database = await resolve(http, Database)
|
||||
async with database.connection() as connection:
|
||||
assert await connection.fetchval("SHOW statement_timeout") == "1500ms"
|
||||
assert await connection.fetchval("SHOW lock_timeout") == "1500ms"
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user