Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
117a7783aa |
+3
-12
@@ -1,13 +1,4 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
POSTGRES_DB=messenger
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=change-this-for-local-demo
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
FROM python:3.14.8-slim-bookworm
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080 \
|
||||
APP_ENV=lab
|
||||
|
||||
WORKDIR /app
|
||||
COPY requirements.txt ./
|
||||
RUN python -m pip install --no-cache-dir -r requirements.txt
|
||||
RUN groupadd --gid 10001 appuser \
|
||||
&& useradd --uid 10001 --gid appuser --no-create-home --shell /usr/sbin/nologin appuser
|
||||
|
||||
COPY src ./src
|
||||
COPY migrations ./migrations
|
||||
COPY tests ./tests
|
||||
COPY scripts ./scripts
|
||||
COPY contracts ./contracts
|
||||
COPY lab.json ./
|
||||
|
||||
USER 10001:10001
|
||||
EXPOSE 8080
|
||||
STOPSIGNAL SIGTERM
|
||||
HEALTHCHECK --interval=5s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready', timeout=2).close()"]
|
||||
|
||||
CMD ["python", "-m", "src.run"]
|
||||
@@ -4,7 +4,7 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
.PHONY: help check validate test load test-parallel test-persistence test-failover
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@@ -18,6 +18,9 @@ validate:
|
||||
test:
|
||||
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-parallel:
|
||||
$(PYTHON) scripts/test_parallel.py
|
||||
|
||||
load:
|
||||
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
|
||||
@@ -1,37 +1,107 @@
|
||||
# Отчёт — лабораторная 3
|
||||
# Лабораторная работа №3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
Группа БВТ2302, Рестеу Д. А.
|
||||
Цель: балансировка API и проверка работы при отказе одной реплики.
|
||||
Планируемая оценка: 4.
|
||||
|
||||
## Запуск из чистого clone
|
||||
## Что сделал
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Взял REST API из второй лабораторной. PostgreSQL хранит пользователей, чаты и сообщения, а Redis — сессии. Эти данные не лежат в памяти отдельного API, поэтому оба экземпляра работают с одной базой и узнают один токен.
|
||||
|
||||
## Архитектура и решения
|
||||
В `compose.yaml` добавил два сервиса `api1` и `api2`, а перед ними Nginx (`lb`). Снаружи опубликован только `127.0.0.1:8080`, запросы к репликам идут через внутреннюю сеть Docker. В каждом ответе API есть `X-Instance-Id`: `api1` или `api2`.
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Добавил миграцию `03_idempotency.sql` с таблицей `message_requests`. Отправка сообщения теперь требует `Idempotency-Key`. Первая транзакция сохраняет сообщение и информацию о ключе вместе. Повтор с тем же ключом и текстом возвращает исходное сообщение, а повтор с другим текстом возвращает 409. Уникальный первичный ключ в PostgreSQL не позволяет параллельным запросам создать два сообщения. Срок действия ключа — 24 часа.
|
||||
|
||||
## Доказательства критериев
|
||||
Для проверки готовности оставил `/health/live` и `/health/ready`. Второй endpoint проверяет PostgreSQL и Redis. В Nginx настроил DNS-переопределение адресов, таймауты и пассивное исключение недоступного API. У контейнеров API лимит 0,5 CPU и 256 MiB памяти. Отдельный `migrate` применяет SQL до запуска реплик.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
## Запуск
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
Нужны Docker Desktop с Compose и Python 3.9+ для проверок. Команды выполнять из корня лабораторной.
|
||||
|
||||
## Эксперименты и отказы
|
||||
Для PowerShell:
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
```powershell
|
||||
Copy-Item .env.example .env
|
||||
# В .env заменяю POSTGRES_PASSWORD на свой локальный пароль
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
docker compose --env-file .env up -d --build --wait
|
||||
docker compose --env-file .env ps
|
||||
python tests/smoke.py --base-url http://localhost:8080
|
||||
python scripts/test_parallel.py
|
||||
```
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
Swagger: http://localhost:8080/docs. Все запросы к API в тестах идут только через Nginx.
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Проверка отказа прямо в PowerShell (без `make` и WSL):
|
||||
|
||||
```powershell
|
||||
python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd
|
||||
# Вернуть обе реплики
|
||||
docker compose up -d --wait api1 api2
|
||||
python tests/resilience.py --mode persistence --action-script scripts/restart.cmd
|
||||
```
|
||||
|
||||
Для Linux/WSL с `make`:
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
# Изменить пароль в .env
|
||||
chmod +x scripts/*.sh
|
||||
make check
|
||||
make test
|
||||
make test-parallel
|
||||
```
|
||||
|
||||
При необходимости перед запуском проверяю настройки командой `docker compose --env-file .env config --quiet`.
|
||||
|
||||
## Проверка отказа
|
||||
|
||||
Сначала запустить `make test` и `make test-parallel`. Затем в Linux/WSL:
|
||||
|
||||
```sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
# После теста посмотреть реально остановленный контейнер:
|
||||
docker compose ps -a
|
||||
# Восстановить обе реплики:
|
||||
docker compose up -d --wait api1 api2
|
||||
# Повторить failover: тест сам выберет инстанс первого сообщения
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
# Вернуть реплики
|
||||
docker compose up -d --wait api1 api2
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
```
|
||||
|
||||
Скрипт `stop-one.sh` читает `TARGET_INSTANCE_ID` из теста и останавливает именно выбранную реплику. Если реплика уже остановлена, перед следующим запуском её нужно поднять.
|
||||
|
||||
Для поочередного обновления после сборки образа:
|
||||
|
||||
```sh
|
||||
docker compose build api1 api2
|
||||
./scripts/rolling-update.sh
|
||||
```
|
||||
|
||||
На время этой операции отдельно запускаю `python tests/load.py --duration 30 --concurrency 4 --output evidence/rolling-load.json`, после чего просматриваю сохранённые показатели. На Windows для обновления использую `scripts/rolling-update.cmd`. Важно: для подтверждения обновления тест нагрузки должен идти одновременно со скриптом обновления.
|
||||
|
||||
## Проверки и доказательства
|
||||
|
||||
| Проверка | Команда | Что должно получиться |
|
||||
| --- | --- | --- |
|
||||
| Структура | `make check` | PASS |
|
||||
| Запуск и API | `make test` | PASS, один полный пользовательский сценарий |
|
||||
| Две реплики | повтор `GET /health/live` | ответы с разными `X-Instance-Id` |
|
||||
| Одновременный повтор POST | `make test-parallel` | один ID сообщения в 12 ответах |
|
||||
| Отказ реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | запись продолжается через другую реплику |
|
||||
| Сохранение данных | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | тот же токен и сообщения после перезапуска |
|
||||
| Нагрузка | `make load` | фактические RPS, ошибки, p50/p95/p99 |
|
||||
|
||||
Реальные результаты `test-failover` и `load` нужно записать после запуска стенда на своём компьютере. До запуска Docker эти проверки не считаю выполненными.
|
||||
|
||||
## Ограничения
|
||||
|
||||
Решение выдерживает остановку одного API, но не остановку Nginx, Redis, PostgreSQL или всего Docker-хоста — это оставшиеся единые точки отказа. Nginx проверяет недоступность через ошибки и таймауты запросов, а не активным опросом каждой реплики. Настроены `fail_timeout=2s`, `proxy_connect_timeout=1s`; фактическое восстановление проверяется отдельным failover-тестом. Команда `docker compose down -v` удалит тестовые данные, обычная `docker compose down` — нет.
|
||||
|
||||
## Ссылки
|
||||
|
||||
- https://docs.docker.com/reference/compose-file/services/
|
||||
- https://nginx.org/ru/docs/http/ngx_http_upstream_module.html
|
||||
- https://www.postgresql.org/docs/current/sql-insert.html
|
||||
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:17.11-bookworm
|
||||
environment:
|
||||
POSTGRES_DB: ${POSTGRES_DB:?Set POSTGRES_DB in .env}
|
||||
POSTGRES_USER: ${POSTGRES_USER:?Set POSTGRES_USER in .env}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
cpus: 1.0
|
||||
mem_limit: 512m
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:8.2.10-bookworm
|
||||
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
|
||||
volumes:
|
||||
- redis_data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
cpus: 0.50
|
||||
mem_limit: 256m
|
||||
restart: unless-stopped
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
command: ["python", "-m", "src.migrate"]
|
||||
environment: &db_env
|
||||
POSTGRES_DB: ${POSTGRES_DB}
|
||||
POSTGRES_USER: ${POSTGRES_USER}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
cpus: 0.50
|
||||
mem_limit: 256m
|
||||
restart: "no"
|
||||
|
||||
api1:
|
||||
build: .
|
||||
environment:
|
||||
<<: *db_env
|
||||
INSTANCE_ID: api1
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
depends_on: &api_depends
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
healthcheck: &api_health
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).close()"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 3
|
||||
start_period: 10s
|
||||
cpus: 0.50
|
||||
mem_limit: 256m
|
||||
stop_grace_period: 15s
|
||||
restart: unless-stopped
|
||||
|
||||
api2:
|
||||
build: .
|
||||
environment:
|
||||
<<: *db_env
|
||||
INSTANCE_ID: api2
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
depends_on: *api_depends
|
||||
healthcheck: *api_health
|
||||
cpus: 0.50
|
||||
mem_limit: 256m
|
||||
stop_grace_period: 15s
|
||||
restart: unless-stopped
|
||||
|
||||
lb:
|
||||
image: nginx:1.28.0-alpine
|
||||
cpus: 0.50
|
||||
mem_limit: 128m
|
||||
volumes:
|
||||
- ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
|
||||
- ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
depends_on:
|
||||
api1:
|
||||
condition: service_healthy
|
||||
api2:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/health/ready"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 3
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
redis_data:
|
||||
@@ -0,0 +1,9 @@
|
||||
Результаты экспериментов добавляю после запуска Docker на своём компьютере.
|
||||
|
||||
1. `docker compose ps -a` — какие контейнеры работают.
|
||||
2. `python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json`
|
||||
3. `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` — вывод с successful_writes, failed_attempts, first_recovery_seconds.
|
||||
4. `make test-persistence ACTION_SCRIPT=scripts/restart.sh` — проверка сохранения данных.
|
||||
5. Отдельный `rolling-update.sh` во время `tests/load.py`.
|
||||
|
||||
Не добавляю туда токены и пароли.
|
||||
@@ -0,0 +1,30 @@
|
||||
CREATE TABLE users (
|
||||
id UUID PRIMARY KEY,
|
||||
username VARCHAR(32) NOT NULL UNIQUE,
|
||||
display_name VARCHAR(100) NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title VARCHAR(100) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats(id),
|
||||
user_id UUID NOT NULL REFERENCES users(id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID NOT NULL REFERENCES chats(id),
|
||||
sender_id UUID NOT NULL REFERENCES users(id),
|
||||
text VARCHAR(4000) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1 @@
|
||||
CREATE INDEX chats_order_idx ON chats (created_at, id);
|
||||
@@ -0,0 +1,11 @@
|
||||
CREATE TABLE message_requests (
|
||||
sender_id UUID NOT NULL REFERENCES users(id),
|
||||
chat_id UUID NOT NULL REFERENCES chats(id),
|
||||
request_key VARCHAR(128) NOT NULL,
|
||||
request_hash CHAR(64) NOT NULL,
|
||||
message_id UUID REFERENCES messages(id),
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (sender_id, chat_id, request_key)
|
||||
);
|
||||
|
||||
CREATE INDEX message_requests_created_idx ON message_requests (created_at);
|
||||
@@ -0,0 +1,25 @@
|
||||
upstream api_backends {
|
||||
zone api_backends 64k;
|
||||
resolver 127.0.0.11 valid=2s ipv6=off;
|
||||
server api1:8080 resolve max_fails=1 fail_timeout=2s;
|
||||
server api2:8080 resolve max_fails=1 fail_timeout=2s;
|
||||
}
|
||||
|
||||
server {
|
||||
listen 8080;
|
||||
server_name _;
|
||||
|
||||
location / {
|
||||
proxy_pass http://api_backends;
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header Connection "";
|
||||
proxy_connect_timeout 1s;
|
||||
proxy_read_timeout 7s;
|
||||
proxy_send_timeout 7s;
|
||||
proxy_next_upstream error timeout http_502 http_503 http_504;
|
||||
proxy_next_upstream_tries 2;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
worker_processes auto;
|
||||
events { worker_connections 1024; }
|
||||
http {
|
||||
access_log /dev/stdout;
|
||||
error_log /dev/stderr warn;
|
||||
include /etc/nginx/conf.d/*.conf;
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
annotated-doc==0.0.5
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
click==8.5.0
|
||||
fastapi==0.143.0
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
opentelemetry-api==1.45.1
|
||||
pydantic==2.14.1
|
||||
pydantic_core==2.50.1
|
||||
starlette==1.7.0
|
||||
typing-inspection==0.4.4
|
||||
typing_extensions==4.16.0
|
||||
uvicorn==0.54.0
|
||||
psycopg[binary]==3.3.6
|
||||
psycopg-pool==3.3.3
|
||||
argon2-cffi==25.1.0
|
||||
redis==8.1.0
|
||||
@@ -0,0 +1,6 @@
|
||||
@echo off
|
||||
cd /d "%~dp0.."
|
||||
docker compose --env-file .env stop lb api1 api2 redis postgres
|
||||
if errorlevel 1 exit /b 1
|
||||
docker compose --env-file .env up -d --wait
|
||||
exit /b %errorlevel%
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env stop lb api1 api2 redis postgres
|
||||
docker compose --env-file .env up -d --wait
|
||||
@@ -0,0 +1,6 @@
|
||||
@echo off
|
||||
cd /d "%~dp0.."
|
||||
docker compose --env-file .env up -d --no-deps --force-recreate --wait api1
|
||||
if errorlevel 1 exit /b 1
|
||||
docker compose --env-file .env up -d --no-deps --force-recreate --wait api2
|
||||
exit /b %errorlevel%
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env up -d --no-deps --force-recreate --wait api1
|
||||
docker compose --env-file .env up -d --no-deps --force-recreate --wait api2
|
||||
@@ -0,0 +1,7 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
case "${1:-api1}" in
|
||||
api1|api2) docker compose --env-file .env up -d "$1" ;;
|
||||
*) echo "Usage: scripts/start-one.sh api1|api2" >&2; exit 2 ;;
|
||||
esac
|
||||
@@ -0,0 +1,6 @@
|
||||
@echo off
|
||||
cd /d "%~dp0.."
|
||||
if "%TARGET_INSTANCE_ID%"=="" set "TARGET_INSTANCE_ID=api1"
|
||||
if not "%TARGET_INSTANCE_ID%"=="api1" if not "%TARGET_INSTANCE_ID%"=="api2" exit /b 2
|
||||
docker compose --env-file .env stop %TARGET_INSTANCE_ID%
|
||||
exit /b %errorlevel%
|
||||
@@ -0,0 +1,8 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
case "${TARGET_INSTANCE_ID:-api1}" in
|
||||
api1|api2) target="${TARGET_INSTANCE_ID:-api1}" ;;
|
||||
*) echo "Unknown API replica" >&2; exit 2 ;;
|
||||
esac
|
||||
docker compose --env-file .env stop "$target"
|
||||
@@ -0,0 +1,42 @@
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import threading
|
||||
from uuid import uuid4
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
|
||||
from client import Client, check
|
||||
|
||||
|
||||
def main():
|
||||
client = Client()
|
||||
alice, _, _, chat = client.bootstrap()
|
||||
key = uuid4().hex
|
||||
path = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
text = "Проверка одновременного повтора " + key
|
||||
barrier = threading.Barrier(12)
|
||||
|
||||
def send(_):
|
||||
local = Client(timeout=10)
|
||||
barrier.wait(timeout=10)
|
||||
response = local.message(alice, chat, text, key=key)
|
||||
return response["json"], response["headers"]["X-Instance-Id"]
|
||||
|
||||
with ThreadPoolExecutor(max_workers=12) as workers:
|
||||
results = list(workers.map(send, range(12)))
|
||||
|
||||
ids = {message["id"] for message, _ in results}
|
||||
instances = {instance for _, instance in results}
|
||||
check(len(ids) == 1, "Повтор создал несколько сообщений")
|
||||
check(len(instances) == 2, "Не удалось проверить обе реплики")
|
||||
check(all(result[0] == results[0][0] for result in results), "Ответы различаются")
|
||||
client.call("POST", path, 409, actor=alice, body={"text": "Другой текст"},
|
||||
headers={"Idempotency-Key": key})
|
||||
page = client.call("GET", path + "?limit=100", actor=alice, schema="MessagePage")["json"]
|
||||
check(sum(item["id"] in ids for item in page["items"]) == 1,
|
||||
"В истории найден дубль сообщения")
|
||||
print("PASS: 12 параллельных запросов; 2 реплики; 1 сообщение; повтор с другим текстом — 409")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,29 @@
|
||||
import os
|
||||
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
|
||||
def connection_kwargs():
|
||||
return {
|
||||
"host": os.getenv("POSTGRES_HOST", "postgres"),
|
||||
"port": int(os.getenv("POSTGRES_PORT", "5432")),
|
||||
"dbname": os.environ["POSTGRES_DB"],
|
||||
"user": os.environ["POSTGRES_USER"],
|
||||
"password": os.environ["POSTGRES_PASSWORD"],
|
||||
"connect_timeout": 5,
|
||||
"options": "-c statement_timeout=5000 -c lock_timeout=3000",
|
||||
"autocommit": True,
|
||||
"row_factory": dict_row,
|
||||
}
|
||||
|
||||
|
||||
pool = ConnectionPool(
|
||||
kwargs=connection_kwargs(),
|
||||
min_size=1,
|
||||
max_size=5,
|
||||
max_waiting=20,
|
||||
timeout=3,
|
||||
check=ConnectionPool.check_connection,
|
||||
open=False,
|
||||
)
|
||||
@@ -0,0 +1,14 @@
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status, code, message):
|
||||
super().__init__(message)
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
|
||||
|
||||
def invalid(message="Неверный запрос"):
|
||||
raise ApiError(400, "invalid_request", message)
|
||||
|
||||
|
||||
def unauthorized():
|
||||
raise ApiError(401, "unauthorized", "Неверные данные авторизации")
|
||||
+445
@@ -0,0 +1,445 @@
|
||||
import base64
|
||||
import binascii
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import logging
|
||||
import re
|
||||
import time
|
||||
from contextlib import asynccontextmanager
|
||||
from datetime import datetime, timezone
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerifyMismatchError
|
||||
from fastapi import FastAPI, Header, Query, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from psycopg import InterfaceError, OperationalError
|
||||
from psycopg.errors import ForeignKeyViolation, UniqueViolation
|
||||
from pydantic import BaseModel, ConfigDict, Field, field_validator
|
||||
from redis.exceptions import RedisError
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from src.db import pool
|
||||
from src.errors import ApiError, invalid, unauthorized
|
||||
from src.pagination import encode_cursor, parse_page
|
||||
from src.sessions import issue_session, redis_client
|
||||
|
||||
|
||||
log = logging.getLogger("messenger")
|
||||
password_hasher = PasswordHasher()
|
||||
INSTANCE_ID = os.getenv("INSTANCE_ID", uuid4().hex)
|
||||
ready = False
|
||||
|
||||
|
||||
def parse_uuid(value):
|
||||
try:
|
||||
return UUID(value)
|
||||
except (ValueError, TypeError, AttributeError):
|
||||
invalid("Некорректный UUID")
|
||||
|
||||
|
||||
def row_response(row):
|
||||
result = {}
|
||||
for key, value in row.items():
|
||||
if isinstance(value, UUID):
|
||||
value = str(value)
|
||||
elif isinstance(value, datetime):
|
||||
value = value.astimezone(timezone.utc).isoformat(
|
||||
timespec="microseconds"
|
||||
).replace("+00:00", "Z")
|
||||
elif key == "member_ids":
|
||||
value = [str(member) for member in value]
|
||||
result[key] = value
|
||||
return result
|
||||
|
||||
|
||||
class InputModel(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
@field_validator("*", check_fields=False)
|
||||
@classmethod
|
||||
def reject_blank(cls, value):
|
||||
if isinstance(value, str) and not value.strip():
|
||||
raise ValueError("Строка не должна быть пустой")
|
||||
return value
|
||||
|
||||
@field_validator("display_name", "title", "text", check_fields=False)
|
||||
@classmethod
|
||||
def reject_nul(cls, value):
|
||||
if "\u0000" in value:
|
||||
raise ValueError("Нулевой символ недопустим в текстовом поле")
|
||||
return value
|
||||
|
||||
|
||||
class CreateUser(InputModel):
|
||||
username: str = Field(min_length=3, max_length=32)
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
password: str = Field(min_length=12, max_length=128)
|
||||
|
||||
@field_validator("username")
|
||||
@classmethod
|
||||
def validate_username(cls, value):
|
||||
if re.fullmatch(r"[a-z0-9_]{3,32}", value) is None:
|
||||
raise ValueError("Некорректный username")
|
||||
return value
|
||||
|
||||
|
||||
class CreateChat(InputModel):
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: list[str] = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class CreateMessage(InputModel):
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
|
||||
|
||||
def bearer_token(value):
|
||||
scheme, _, token = (value or "").partition(" ")
|
||||
if scheme.lower() != "bearer" or not token:
|
||||
unauthorized()
|
||||
return token
|
||||
|
||||
|
||||
def current_user(value):
|
||||
token = bearer_token(value)
|
||||
user_id = redis_client.get("session:" + token)
|
||||
if user_id is None:
|
||||
unauthorized()
|
||||
with pool.connection() as conn:
|
||||
user = conn.execute(
|
||||
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
||||
(UUID(user_id),),
|
||||
).fetchone()
|
||||
if user is None:
|
||||
unauthorized()
|
||||
return row_response(user)
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app):
|
||||
global ready
|
||||
try:
|
||||
await run_in_threadpool(pool.open, wait=True, timeout=10)
|
||||
await run_in_threadpool(redis_client.ping)
|
||||
ready = True
|
||||
log.info("startup ready=true")
|
||||
yield
|
||||
finally:
|
||||
ready = False
|
||||
redis_client.close()
|
||||
pool.close()
|
||||
log.info("shutdown complete")
|
||||
|
||||
|
||||
app = FastAPI(title="Lab 3 Messenger", lifespan=lifespan)
|
||||
|
||||
|
||||
def error_response(request, status, code, message):
|
||||
request_id = request.state.request_id
|
||||
headers = {"X-Request-Id": request_id}
|
||||
if status == 401:
|
||||
if request.method == "POST" and request.url.path == "/api/v1/auth/sessions":
|
||||
headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"'
|
||||
else:
|
||||
headers["WWW-Authenticate"] = 'Bearer realm="messenger"'
|
||||
return JSONResponse(
|
||||
status_code=status,
|
||||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(ApiError)
|
||||
async def api_error(request, exc):
|
||||
return error_response(request, exc.status, exc.code, exc.message)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_error(request, exc):
|
||||
return error_response(request, 400, "invalid_request", "Некорректные поля или JSON")
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_error(request, exc):
|
||||
code = "not_found" if exc.status_code == 404 else "invalid_request"
|
||||
return error_response(request, exc.status_code, code, "Некорректный запрос")
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def process_request(request: Request, call_next):
|
||||
request.state.request_id = str(uuid4())
|
||||
started = time.perf_counter()
|
||||
try:
|
||||
is_login = request.method == "POST" and request.url.path == "/api/v1/auth/sessions"
|
||||
public = request.method == "POST" and request.url.path in (
|
||||
"/api/v1/users", "/api/v1/auth/sessions"
|
||||
)
|
||||
if request.url.path.startswith("/api/v1/") and not public:
|
||||
request.state.user = await run_in_threadpool(
|
||||
current_user, request.headers.get("Authorization")
|
||||
)
|
||||
if is_login:
|
||||
if await request.body():
|
||||
invalid("Для входа тело запроса должно быть пустым")
|
||||
elif request.method == "POST" and request.url.path.startswith("/api/v1/"):
|
||||
media_type = request.headers.get("content-type", "").split(";")[0]
|
||||
if media_type.strip().lower() != "application/json":
|
||||
raise ApiError(415, "unsupported_media_type", "Нужен application/json")
|
||||
response = await call_next(request)
|
||||
except ApiError as exc:
|
||||
response = error_response(request, exc.status, exc.code, exc.message)
|
||||
except (OperationalError, InterfaceError, RedisError):
|
||||
response = error_response(request, 503, "unavailable", "Хранилище недоступно")
|
||||
except Exception as exc:
|
||||
log.error("request_failed type=%s request_id=%s",
|
||||
type(exc).__name__, request.state.request_id)
|
||||
response = error_response(request, 500, "internal_error", "Внутренняя ошибка")
|
||||
response.headers["X-Request-Id"] = request.state.request_id
|
||||
response.headers["X-Instance-Id"] = INSTANCE_ID
|
||||
route = request.scope.get("route")
|
||||
log.info("request method=%s route=%s status=%s duration_ms=%.2f request_id=%s",
|
||||
request.method, getattr(route, "path", "unmatched"), response.status_code,
|
||||
(time.perf_counter() - started) * 1000, request.state.request_id)
|
||||
return response
|
||||
|
||||
|
||||
@app.get("/health/live")
|
||||
def live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
def readiness():
|
||||
if not ready:
|
||||
raise ApiError(503, "unavailable", "Приложение не готово")
|
||||
with pool.connection() as conn:
|
||||
conn.execute("SELECT 1")
|
||||
redis_client.ping()
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
def create_user(body: CreateUser):
|
||||
password_hash = password_hasher.hash(body.password)
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
user = conn.execute(
|
||||
"INSERT INTO users (id, username, display_name, password_hash) "
|
||||
"VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at",
|
||||
(uuid4(), body.username, body.display_name, password_hash),
|
||||
).fetchone()
|
||||
except UniqueViolation as exc:
|
||||
if exc.diag.constraint_name == "users_username_key":
|
||||
raise ApiError(409, "conflict", "Username занят") from None
|
||||
raise
|
||||
return row_response(user)
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
def login(authorization: str | None = Header(default=None)):
|
||||
scheme, _, encoded = (authorization or "").partition(" ")
|
||||
if scheme.lower() != "basic" or not encoded:
|
||||
unauthorized()
|
||||
try:
|
||||
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
|
||||
username, password = decoded.split(":", 1)
|
||||
except (ValueError, binascii.Error):
|
||||
unauthorized()
|
||||
if re.fullmatch(r"[a-z0-9_]{3,32}", username) is None or not 12 <= len(password) <= 128:
|
||||
unauthorized()
|
||||
with pool.connection() as conn:
|
||||
user = conn.execute(
|
||||
"SELECT id, username, display_name, password_hash, created_at "
|
||||
"FROM users WHERE username = %s", (username,),
|
||||
).fetchone()
|
||||
if user is None:
|
||||
unauthorized()
|
||||
try:
|
||||
password_hasher.verify(user["password_hash"], password)
|
||||
except VerifyMismatchError:
|
||||
unauthorized()
|
||||
token, expires_at = issue_session(user["id"])
|
||||
del user["password_hash"]
|
||||
return {"token": token, "token_type": "Bearer", "expires_at": expires_at,
|
||||
"user": row_response(user)}
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
def logout(request: Request):
|
||||
token = bearer_token(request.headers.get("Authorization"))
|
||||
redis_client.delete("session:" + token)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
def get_me(request: Request):
|
||||
return request.state.user
|
||||
|
||||
|
||||
def require_member(conn, chat_id, user_id):
|
||||
found = conn.execute(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(chat_id, UUID(user_id)),
|
||||
).fetchone()
|
||||
if found is None:
|
||||
raise ApiError(404, "not_found", "Чат не найден")
|
||||
|
||||
|
||||
CHAT_SELECT = """
|
||||
SELECT c.id, c.title, c.created_at,
|
||||
ARRAY(SELECT user_id FROM chat_members
|
||||
WHERE chat_id = c.id ORDER BY user_id) AS member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members mine ON mine.chat_id = c.id
|
||||
WHERE mine.user_id = %s
|
||||
"""
|
||||
|
||||
HISTORY_FIRST_SQL = """
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages WHERE chat_id = %s
|
||||
ORDER BY created_at, id LIMIT %s
|
||||
"""
|
||||
|
||||
HISTORY_AFTER_SQL = """
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages WHERE chat_id = %s AND (created_at, id) > (%s, %s)
|
||||
ORDER BY created_at, id LIMIT %s
|
||||
"""
|
||||
|
||||
|
||||
def page_response(rows, size, scope):
|
||||
items = [row_response(row) for row in rows[:size]]
|
||||
cursor = encode_cursor(scope, items[-1]) if len(rows) > size else None
|
||||
return {"items": items, "next_cursor": cursor}
|
||||
|
||||
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
def create_chat(body: CreateChat, request: Request):
|
||||
members = sorted(parse_uuid(value) for value in body.member_ids)
|
||||
if len(members) != len(set(members)):
|
||||
invalid("Участники повторяются")
|
||||
if UUID(request.state.user["id"]) not in members:
|
||||
invalid("Вызывающий должен входить в member_ids")
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
chat = conn.execute(
|
||||
"INSERT INTO chats (id, title) VALUES (%s, %s) "
|
||||
"RETURNING id, title, created_at", (uuid4(), body.title),
|
||||
).fetchone()
|
||||
with conn.cursor() as cur:
|
||||
cur.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
|
||||
[(chat["id"], member) for member in members],
|
||||
)
|
||||
except ForeignKeyViolation:
|
||||
invalid("Неизвестный участник")
|
||||
chat["member_ids"] = members
|
||||
return row_response(chat)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats")
|
||||
def list_chats(request: Request, limit: str = Query(default="50"),
|
||||
cursor: str | None = Query(default=None)):
|
||||
user_id = request.state.user["id"]
|
||||
scope = "chats:" + user_id
|
||||
size, after = parse_page(limit, cursor, scope)
|
||||
query = CHAT_SELECT
|
||||
params = [UUID(user_id)]
|
||||
if after is not None:
|
||||
query += " AND (c.created_at, c.id) > (%s, %s)"
|
||||
params.extend(after)
|
||||
query += " ORDER BY c.created_at, c.id LIMIT %s"
|
||||
params.append(size + 1)
|
||||
with pool.connection() as conn:
|
||||
rows = conn.execute(query, params).fetchall()
|
||||
return page_response(rows, size, scope)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
def get_chat(chat_id: str, request: Request):
|
||||
with pool.connection() as conn:
|
||||
chat = conn.execute(
|
||||
CHAT_SELECT + " AND c.id = %s",
|
||||
(UUID(request.state.user["id"]), parse_uuid(chat_id)),
|
||||
).fetchone()
|
||||
if chat is None:
|
||||
raise ApiError(404, "not_found", "Чат не найден")
|
||||
return row_response(chat)
|
||||
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
def create_message(
|
||||
chat_id: str,
|
||||
body: CreateMessage,
|
||||
request: Request,
|
||||
idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"),
|
||||
):
|
||||
if idempotency_key is None or re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", idempotency_key) is None:
|
||||
invalid("Некорректный Idempotency-Key")
|
||||
|
||||
chat_uuid = parse_uuid(chat_id)
|
||||
user_id = UUID(request.state.user["id"])
|
||||
digest = hashlib.sha256(
|
||||
json.dumps({"text": body.text}, ensure_ascii=False, sort_keys=True).encode("utf-8")
|
||||
).hexdigest()
|
||||
|
||||
with pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
require_member(conn, chat_uuid, str(user_id))
|
||||
conn.execute(
|
||||
"DELETE FROM message_requests WHERE sender_id = %s AND chat_id = %s "
|
||||
"AND request_key = %s AND created_at < now() - interval '24 hours'",
|
||||
(user_id, chat_uuid, idempotency_key),
|
||||
)
|
||||
created = conn.execute(
|
||||
"INSERT INTO message_requests (sender_id, chat_id, request_key, request_hash) "
|
||||
"VALUES (%s, %s, %s, %s) ON CONFLICT DO NOTHING RETURNING request_key",
|
||||
(user_id, chat_uuid, idempotency_key, digest),
|
||||
).fetchone()
|
||||
if created is None:
|
||||
existing = conn.execute(
|
||||
"SELECT request_hash, message_id FROM message_requests "
|
||||
"WHERE sender_id = %s AND chat_id = %s AND request_key = %s",
|
||||
(user_id, chat_uuid, idempotency_key),
|
||||
).fetchone()
|
||||
if existing is None:
|
||||
raise ApiError(503, "unavailable", "Повторите запрос")
|
||||
if existing["request_hash"] != digest:
|
||||
raise ApiError(409, "conflict", "Ключ уже использован для другого сообщения")
|
||||
message = conn.execute(
|
||||
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE id = %s",
|
||||
(existing["message_id"],),
|
||||
).fetchone()
|
||||
else:
|
||||
message = conn.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text) "
|
||||
"VALUES (%s, %s, %s, %s) "
|
||||
"RETURNING id, chat_id, sender_id, text, created_at",
|
||||
(uuid4(), chat_uuid, user_id, body.text),
|
||||
).fetchone()
|
||||
conn.execute(
|
||||
"UPDATE message_requests SET message_id = %s "
|
||||
"WHERE sender_id = %s AND chat_id = %s AND request_key = %s",
|
||||
(message["id"], user_id, chat_uuid, idempotency_key),
|
||||
)
|
||||
return row_response(message)
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
def list_messages(chat_id: str, request: Request, limit: str = Query(default="50"),
|
||||
cursor: str | None = Query(default=None)):
|
||||
chat_uuid = parse_uuid(chat_id)
|
||||
scope = "messages:" + str(chat_uuid)
|
||||
size, after = parse_page(limit, cursor, scope)
|
||||
with pool.connection() as conn:
|
||||
require_member(conn, chat_uuid, request.state.user["id"])
|
||||
if after is None:
|
||||
rows = conn.execute(HISTORY_FIRST_SQL, (chat_uuid, size + 1)).fetchall()
|
||||
else:
|
||||
rows = conn.execute(
|
||||
HISTORY_AFTER_SQL, (chat_uuid, after[0], after[1], size + 1)
|
||||
).fetchall()
|
||||
return page_response(rows, size, scope)
|
||||
@@ -0,0 +1,36 @@
|
||||
from pathlib import Path
|
||||
|
||||
import psycopg
|
||||
|
||||
from src.db import connection_kwargs
|
||||
|
||||
|
||||
def main():
|
||||
files = sorted((Path(__file__).resolve().parents[1] / "migrations").glob("*.sql"))
|
||||
if not files:
|
||||
raise RuntimeError("Миграции не найдены")
|
||||
with psycopg.connect(**connection_kwargs()) as conn:
|
||||
conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
)
|
||||
""")
|
||||
for file in files:
|
||||
applied = False
|
||||
with conn.transaction():
|
||||
conn.execute("SELECT pg_advisory_xact_lock(202602)")
|
||||
exists = conn.execute(
|
||||
"SELECT 1 FROM schema_migrations WHERE version = %s", (file.name,)
|
||||
).fetchone()
|
||||
if exists is None:
|
||||
conn.execute(file.read_text(encoding="utf-8"))
|
||||
conn.execute(
|
||||
"INSERT INTO schema_migrations (version) VALUES (%s)", (file.name,)
|
||||
)
|
||||
applied = True
|
||||
print(("APPLIED " if applied else "SKIP ") + file.name)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,47 @@
|
||||
import base64
|
||||
import binascii
|
||||
import json
|
||||
import re
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from src.errors import invalid
|
||||
|
||||
|
||||
def encode_cursor(scope, item):
|
||||
data = {"scope": scope, "created_at": item["created_at"], "id": item["id"]}
|
||||
raw = json.dumps(data, separators=(",", ":")).encode("utf-8")
|
||||
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def parse_page(limit, cursor, scope):
|
||||
if len(limit) > 10 or re.fullmatch(r"[0-9]+", limit) is None:
|
||||
invalid("limit должен быть целым числом от 1 до 100")
|
||||
size = int(limit)
|
||||
if not 1 <= size <= 100:
|
||||
invalid("limit должен быть от 1 до 100")
|
||||
if cursor is None:
|
||||
return size, None
|
||||
if not cursor or len(cursor) > 2048:
|
||||
invalid("Некорректный cursor")
|
||||
try:
|
||||
raw = base64.b64decode(
|
||||
cursor + "=" * (-len(cursor) % 4), altchars=b"-_", validate=True
|
||||
)
|
||||
data = json.loads(raw)
|
||||
if not isinstance(data, dict) or set(data) != {"scope", "created_at", "id"}:
|
||||
raise ValueError
|
||||
if data["scope"] != scope or not isinstance(data["created_at"], str):
|
||||
raise ValueError
|
||||
if re.fullmatch(
|
||||
r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,6})?Z",
|
||||
data["created_at"],
|
||||
) is None:
|
||||
raise ValueError
|
||||
created_at = datetime.fromisoformat(data["created_at"][:-1] + "+00:00")
|
||||
if created_at.tzinfo is None:
|
||||
raise ValueError
|
||||
item_id = UUID(data["id"])
|
||||
except (ValueError, TypeError, AttributeError, binascii.Error):
|
||||
invalid("Некорректный cursor или cursor от другого ресурса")
|
||||
return size, (created_at, item_id)
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
import logging
|
||||
import os
|
||||
|
||||
import uvicorn
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
)
|
||||
logging.getLogger("messenger").info(
|
||||
"config app_env=%s", os.getenv("APP_ENV", "lab")
|
||||
)
|
||||
uvicorn.run(
|
||||
"src.main:app",
|
||||
host=os.getenv("APP_HOST", "0.0.0.0"),
|
||||
port=int(os.getenv("APP_PORT", "8080")),
|
||||
workers=1,
|
||||
timeout_graceful_shutdown=5,
|
||||
timeout_keep_alive=1,
|
||||
access_log=False,
|
||||
)
|
||||
@@ -0,0 +1,33 @@
|
||||
import os
|
||||
import secrets
|
||||
import time
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from redis import Redis
|
||||
from redis.backoff import NoBackoff
|
||||
from redis.retry import Retry
|
||||
|
||||
|
||||
redis_client = Redis(
|
||||
host=os.getenv("REDIS_HOST", "redis"),
|
||||
port=int(os.getenv("REDIS_PORT", "6379")),
|
||||
decode_responses=True,
|
||||
socket_connect_timeout=2,
|
||||
socket_timeout=2,
|
||||
max_connections=10,
|
||||
retry=Retry(NoBackoff(), 0),
|
||||
)
|
||||
|
||||
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
if SESSION_TTL_SECONDS <= 0:
|
||||
raise RuntimeError("SESSION_TTL_SECONDS должен быть положительным")
|
||||
|
||||
|
||||
def issue_session(user_id):
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_ms = int(time.time() * 1000) + SESSION_TTL_SECONDS * 1000
|
||||
redis_client.set("session:" + token, str(user_id), pxat=expires_ms)
|
||||
expires_at = datetime.fromtimestamp(
|
||||
expires_ms / 1000, timezone.utc
|
||||
).isoformat(timespec="milliseconds").replace("+00:00", "Z")
|
||||
return token, expires_at
|
||||
Reference in New Issue
Block a user