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:
Artyom
2026-10-28 11:26:15 +03:00
co-authored by Claude Opus 5.5
parent 0ec2f9dae3
commit 416ce4f9db
111 changed files with 7066 additions and 1 deletions
+24
View File
@@ -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
+5
View File
@@ -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
+58
View File
@@ -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
View File
@@ -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()"]
+76 -1
View File
@@ -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
View File
@@ -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
View File
@@ -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)",
]
+24
View File
@@ -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"
+44
View File
@@ -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 обновлены"
+17
View File
@@ -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
+6
View File
@@ -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
+20
View File
@@ -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"; }
+59
View File
@@ -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;
+40
View File
@@ -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;
View File
+41
View File
@@ -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
View File
@@ -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())
+12
View File
@@ -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)
+17
View File
@@ -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
+25
View File
@@ -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")
+62
View File
@@ -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
+54
View File
@@ -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)
+112
View File
@@ -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)
+103
View File
@@ -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
View File
@@ -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)
+7
View File
@@ -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)
+21
View File
@@ -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
+24
View File
@@ -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")
+3
View File
@@ -0,0 +1,3 @@
from datetime import datetime
type HistoryKey = tuple[datetime, int]
+130
View File
@@ -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
+39
View File
@@ -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)
+70
View File
@@ -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()
+46
View File
@@ -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);
View File
@@ -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)
+42
View File
@@ -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: ...
+48
View File
@@ -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)
+4
View File
@@ -0,0 +1,4 @@
class DomainError(Exception):
def __init__(self, detail: str) -> None:
super().__init__(detail)
self.detail = detail
+6
View File
@@ -0,0 +1,6 @@
from dataclasses import dataclass, field
@dataclass(frozen=True, slots=True)
class DomainEvent:
name: str = field(init=False, default="domain.event")
+16
View File
@@ -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)
+133
View File
@@ -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()
+54
View File
@@ -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
+84
View File
@@ -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
+242
View File
@@ -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}
+118
View File
@@ -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
+88
View File
@@ -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)
+188
View File
@@ -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
+124
View File
@@ -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)
+63
View File
@@ -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()
+196
View File
@@ -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)
+144
View File
@@ -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
+155
View File
@@ -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
+27
View File
@@ -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