forked from mtusi2026/mtusi2026lab4
ЛР 4 — БВТ2304 — Черников — на 4
This commit is contained in:
@@ -0,0 +1 @@
|
||||
"""In-memory мессенджер, лабораторная 1. Только стандартная библиотека Python."""
|
||||
@@ -0,0 +1,94 @@
|
||||
"""Точка входа API: python -m messenger."""
|
||||
import logging
|
||||
import signal
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
|
||||
from .config import load_config
|
||||
from .db import Repository, create_pool
|
||||
from .server import MessengerServer
|
||||
from .sessions import SessionStore
|
||||
from .objects import ObjectStore
|
||||
|
||||
log = logging.getLogger('messenger')
|
||||
|
||||
# Как часто реплика удаляет ключи идемпотентности старше срока хранения.
|
||||
CLEANUP_INTERVAL = 600
|
||||
|
||||
|
||||
def cleanup_idempotency_keys(repo, ttl, stop):
|
||||
"""Фоновая очистка. Каждая реплика делает одно и то же; повторный DELETE безвреден."""
|
||||
while not stop.wait(CLEANUP_INTERVAL):
|
||||
try:
|
||||
deleted = repo.delete_expired_idempotency_keys(ttl)
|
||||
log.info('event=idempotency_cleanup deleted=%d', deleted)
|
||||
except Exception as error: # очистка не должна останавливать реплику
|
||||
log.warning('event=idempotency_cleanup_failed error=%s', type(error).__name__)
|
||||
|
||||
|
||||
def main():
|
||||
config = load_config()
|
||||
logging.Formatter.converter = time.gmtime # время в логах — UTC
|
||||
logging.basicConfig(
|
||||
stream=sys.stdout,
|
||||
level=config.log_level,
|
||||
format='%(asctime)s.%(msecs)03dZ %(levelname)s %(message)s',
|
||||
datefmt='%Y-%m-%dT%H:%M:%S',
|
||||
)
|
||||
# Пул открывается в фоне: если БД ещё не готова, API всё равно стартует,
|
||||
# а /health/ready отвечает 503, пока соединение не появится.
|
||||
pool = create_pool(config.database_url, config.db_pool_size)
|
||||
pool.open(wait=False)
|
||||
sessions = SessionStore(config.cache_url, config.session_ttl)
|
||||
repo = Repository(pool)
|
||||
try:
|
||||
server = MessengerServer((config.host, config.port), repo, sessions, config.instance_id,
|
||||
config.idempotency_ttl, ObjectStore())
|
||||
except OSError as error:
|
||||
log.error('event=bind_failed host=%s port=%d error=%s', config.host, config.port, error)
|
||||
return 1
|
||||
|
||||
# Обработчик сигнала только запоминает номер: всю остановку делает главный поток.
|
||||
received = []
|
||||
|
||||
def on_signal(signum, _frame):
|
||||
received.append(signum)
|
||||
|
||||
for name in ('SIGTERM', 'SIGINT', 'SIGBREAK'): # SIGBREAK есть только в Windows
|
||||
if hasattr(signal, name):
|
||||
signal.signal(getattr(signal, name), on_signal)
|
||||
|
||||
stop_cleanup = threading.Event()
|
||||
threading.Thread(target=cleanup_idempotency_keys, args=(repo, config.idempotency_ttl, stop_cleanup),
|
||||
name='idempotency-cleanup', daemon=True).start()
|
||||
threading.Thread(target=server.serve_forever, name='accept-loop', daemon=True).start()
|
||||
log.info('event=started instance=%s version=%s host=%s port=%d env=%s session_ttl_s=%d db_pool_max=%d '
|
||||
'drain_delay_s=%g shutdown_timeout_s=%g', config.instance_id, config.version, config.host, config.port,
|
||||
config.env, config.session_ttl, config.db_pool_size, config.drain_delay, config.shutdown_timeout)
|
||||
|
||||
while not received:
|
||||
time.sleep(0.1)
|
||||
|
||||
started = time.monotonic()
|
||||
log.info('event=shutdown_started signal=%s', signal.Signals(received[0]).name)
|
||||
# 1. Реплика объявляет себя неготовой, но ещё обслуживает запросы: балансировщик проверяет
|
||||
# /health/ready каждую секунду и после двух неудач (около 2 с) перестаёт слать сюда трафик.
|
||||
server.begin_not_ready()
|
||||
time.sleep(config.drain_delay)
|
||||
# 2. Приём закрывается. Запросы на уже открытых соединениях получают 503.
|
||||
server.begin_drain()
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
# 3. Начатые запросы дорабатывают. Секунда остаётся на закрытие соединений с хранилищами.
|
||||
remaining = config.shutdown_timeout - 1 - (time.monotonic() - started)
|
||||
clean = server.wait_idle(max(remaining, 0))
|
||||
stop_cleanup.set()
|
||||
pool.close(timeout=1)
|
||||
sessions.close()
|
||||
log.info('event=shutdown_finished clean=%s duration_ms=%.0f', clean, (time.monotonic() - started) * 1000)
|
||||
return 0 if clean else 1
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,31 @@
|
||||
"""Идемпотентное создание bucket отдельными административными credentials."""
|
||||
import time
|
||||
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
|
||||
from .objects import ObjectStore
|
||||
|
||||
|
||||
def main():
|
||||
store = ObjectStore(admin=True)
|
||||
for attempt in range(30):
|
||||
try:
|
||||
store.client.create_bucket(Bucket=store.bucket, ACL='private')
|
||||
print('bucket ready (private; authentication configured by s3_config)')
|
||||
return
|
||||
except ClientError as error:
|
||||
if error.response['Error']['Code'] in ('BucketAlreadyOwnedByYou', 'BucketAlreadyExists'):
|
||||
# Нельзя присваивать bucket другого владельца: head с собственным ключом.
|
||||
store.ping()
|
||||
print('bucket already ready')
|
||||
return
|
||||
if attempt == 29:
|
||||
raise
|
||||
except BotoCoreError:
|
||||
if attempt == 29:
|
||||
raise
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,55 @@
|
||||
"""Сборщик неучтённых объектов; default dry-run, grace >= 1 час, повторный запуск безопасен.
|
||||
|
||||
Оператор: docker compose --profile tools run --rm cleanup [--apply]
|
||||
Только originals/. Свежий объект и любая запись БД защищены. Проверка БД и удаление
|
||||
делаются под той же advisory lock, которую upload держит от PUT до COMMIT.
|
||||
При недоступности БД/S3 обход прерывается, никаких delete по неполному снимку.
|
||||
"""
|
||||
import argparse
|
||||
import datetime as dt
|
||||
import json
|
||||
import time
|
||||
|
||||
from .config import read_secret
|
||||
from .db import create_pool
|
||||
from .objects import ObjectStore
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--apply', action='store_true')
|
||||
parser.add_argument('--grace-seconds', type=int, default=3600)
|
||||
args = parser.parse_args()
|
||||
if args.grace_seconds < 3600:
|
||||
parser.error('grace не меньше 3600 секунд')
|
||||
store = ObjectStore(admin=True)
|
||||
pool = create_pool(read_secret('DATABASE_URL'), 1)
|
||||
pool.open(wait=True)
|
||||
cutoff = dt.datetime.now(dt.timezone.utc) - dt.timedelta(seconds=args.grace_seconds)
|
||||
counts = dict(scanned=0, fresh=0, referenced=0, orphan=0, deleted=0)
|
||||
start = time.monotonic()
|
||||
try:
|
||||
pages = store.client.get_paginator('list_objects_v2').paginate(Bucket=store.bucket, Prefix='originals/')
|
||||
for page in pages:
|
||||
for obj in page.get('Contents', []):
|
||||
counts['scanned'] += 1
|
||||
if obj['LastModified'] >= cutoff:
|
||||
counts['fresh'] += 1
|
||||
continue
|
||||
with pool.connection() as conn:
|
||||
conn.execute('SELECT pg_advisory_xact_lock(hashtextextended(%s, 0))', (obj['Key'],))
|
||||
row = conn.execute('SELECT 1 FROM attachments WHERE object_key=%s', (obj['Key'],)).fetchone()
|
||||
if row:
|
||||
counts['referenced'] += 1
|
||||
else:
|
||||
counts['orphan'] += 1
|
||||
if args.apply:
|
||||
store.call('delete_object', Key=obj['Key'])
|
||||
counts['deleted'] += 1
|
||||
finally:
|
||||
pool.close()
|
||||
print(json.dumps(dict(counts, apply=args.apply, seconds=round(time.monotonic()-start, 3))))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,84 @@
|
||||
"""Конфигурация из переменных окружения и файлов секретов (см. .env.example и compose.yaml)."""
|
||||
import os
|
||||
import socket
|
||||
from collections import namedtuple
|
||||
|
||||
Config = namedtuple('Config', 'host port env log_level shutdown_timeout drain_delay session_ttl idempotency_ttl '
|
||||
'db_pool_size database_url cache_url instance_id version')
|
||||
|
||||
LOG_LEVELS = ('DEBUG', 'INFO', 'WARNING', 'ERROR')
|
||||
# Заявленный срок остановки по SIGTERM — не более 10 секунд.
|
||||
MAX_SHUTDOWN_TIMEOUT = 10.0
|
||||
MAX_SESSION_TTL = 30 * 24 * 3600
|
||||
# Контракт: результат идемпотентного запроса хранится не меньше 24 часов.
|
||||
MIN_IDEMPOTENCY_TTL = 24 * 3600
|
||||
|
||||
|
||||
def _environ(environ):
|
||||
# strip(): .env из Windows может принести в значение символ \r.
|
||||
return {name: value.strip() for name, value in (os.environ if environ is None else environ).items()}
|
||||
|
||||
|
||||
def read_secret(name, environ=None):
|
||||
"""Секрет из файла, путь к которому в NAME_FILE (секреты Docker), или из NAME для отладки.
|
||||
|
||||
Значение секрета никогда не попадает в сообщения об ошибках и в логи.
|
||||
"""
|
||||
environ = _environ(environ)
|
||||
path = environ.get(name + '_FILE')
|
||||
if path:
|
||||
try:
|
||||
with open(path, encoding='utf-8') as file:
|
||||
value = file.read().strip()
|
||||
except OSError as error:
|
||||
raise SystemExit('Не удалось прочитать файл из %s_FILE: %s' % (name, error.strerror))
|
||||
else:
|
||||
value = environ.get(name, '')
|
||||
if not value:
|
||||
raise SystemExit('Нужен %s_FILE (путь к файлу секрета) или %s' % (name, name))
|
||||
return value
|
||||
|
||||
|
||||
def _integer(environ, name, default, low, high):
|
||||
try:
|
||||
value = int(environ.get(name, str(default)))
|
||||
except ValueError:
|
||||
raise SystemExit('%s должен быть целым числом' % name)
|
||||
if not low <= value <= high:
|
||||
raise SystemExit('%s должен быть в диапазоне %d..%d' % (name, low, high))
|
||||
return value
|
||||
|
||||
|
||||
def load_config(environ=None):
|
||||
environ = _environ(environ)
|
||||
try:
|
||||
shutdown_timeout = float(environ.get('APP_SHUTDOWN_TIMEOUT', '8'))
|
||||
drain_delay = float(environ.get('APP_DRAIN_DELAY', '3'))
|
||||
except ValueError:
|
||||
raise SystemExit('APP_SHUTDOWN_TIMEOUT и APP_DRAIN_DELAY должны быть числами')
|
||||
if not 0 < shutdown_timeout <= MAX_SHUTDOWN_TIMEOUT:
|
||||
raise SystemExit('APP_SHUTDOWN_TIMEOUT должен быть больше 0 и не больше 10 секунд')
|
||||
# Задержка вывода из балансировщика входит в общий срок остановки, и на сами запросы
|
||||
# должно остаться время.
|
||||
if not 0 <= drain_delay <= shutdown_timeout - 2:
|
||||
raise SystemExit('APP_DRAIN_DELAY должен быть от 0 до APP_SHUTDOWN_TIMEOUT - 2 секунд')
|
||||
log_level = environ.get('APP_LOG_LEVEL', 'INFO').upper()
|
||||
if log_level not in LOG_LEVELS:
|
||||
raise SystemExit('APP_LOG_LEVEL должен быть одним из: ' + ', '.join(LOG_LEVELS))
|
||||
return Config(
|
||||
host=environ.get('APP_HOST', '0.0.0.0'),
|
||||
port=_integer(environ, 'APP_PORT', 8080, 1, 65535),
|
||||
env=environ.get('APP_ENV', 'lab'),
|
||||
log_level=log_level,
|
||||
shutdown_timeout=shutdown_timeout,
|
||||
drain_delay=drain_delay,
|
||||
session_ttl=_integer(environ, 'SESSION_TTL_SECONDS', 3600, 1, MAX_SESSION_TTL),
|
||||
idempotency_ttl=_integer(environ, 'IDEMPOTENCY_TTL_SECONDS', MIN_IDEMPOTENCY_TTL,
|
||||
MIN_IDEMPOTENCY_TTL, MAX_SESSION_TTL),
|
||||
db_pool_size=_integer(environ, 'DB_POOL_SIZE', 10, 1, 50),
|
||||
database_url=read_secret('DATABASE_URL', environ),
|
||||
cache_url=read_secret('CACHE_URL', environ),
|
||||
# X-Instance-Id: в Docker hostname контейнера — короткий ID, по нему хук находит реплику.
|
||||
instance_id=environ.get('INSTANCE_ID') or socket.gethostname(),
|
||||
version=environ.get('APP_VERSION', 'dev'),
|
||||
)
|
||||
@@ -0,0 +1,280 @@
|
||||
"""Доступ к PostgreSQL: ограниченный пул соединений, таймауты, только параметризованные запросы.
|
||||
|
||||
Значения всегда передаются отдельно от текста SQL (%s), поэтому SQL-инъекция невозможна.
|
||||
Каждый метод — одна транзакция: при любой ошибке внутри неё всё откатывается.
|
||||
"""
|
||||
import logging
|
||||
import uuid
|
||||
from contextlib import contextmanager
|
||||
|
||||
import psycopg
|
||||
from psycopg import errors
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
from .errors import Unavailable, not_found
|
||||
from .timeutil import format_time, from_micros, to_micros
|
||||
|
||||
log = logging.getLogger('messenger')
|
||||
|
||||
# Таймауты на стороне сервера БД: долгий запрос, ожидание блокировки и брошенная транзакция
|
||||
# прерываются, а не держат соединение из пула бесконечно.
|
||||
SESSION_OPTIONS = '-c statement_timeout=5000 -c lock_timeout=3000 -c idle_in_transaction_session_timeout=10000'
|
||||
|
||||
MEMBER_IDS = 'array(SELECT m.user_id FROM chat_members m WHERE m.chat_id = c.id ORDER BY m.position) AS member_ids'
|
||||
|
||||
|
||||
class UsernameTaken(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class UnknownMember(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class IdempotencyConflict(Exception):
|
||||
"""Тот же Idempotency-Key уже использован с другим телом запроса."""
|
||||
|
||||
|
||||
def create_pool(database_url, max_size):
|
||||
return ConnectionPool(
|
||||
database_url,
|
||||
min_size=1,
|
||||
max_size=max_size, # не больше max_size соединений с БД на процесс
|
||||
timeout=3, # ждать свободное соединение не дольше 3 с, затем 503
|
||||
max_waiting=100, # очередь ожидающих запросов ограничена
|
||||
check=ConnectionPool.check_connection, # оборванное соединение (рестарт БД) не выдаётся
|
||||
kwargs={
|
||||
'connect_timeout': 3,
|
||||
'application_name': 'messenger-api',
|
||||
'options': SESSION_OPTIONS,
|
||||
'row_factory': dict_row,
|
||||
},
|
||||
name='messenger',
|
||||
open=False,
|
||||
)
|
||||
|
||||
|
||||
def _user(row):
|
||||
return {'id': str(row['id']), 'username': row['username'], 'display_name': row['display_name'],
|
||||
'created_at': format_time(row['created_at'])}
|
||||
|
||||
|
||||
def _chat(row):
|
||||
return {'id': str(row['id']), 'title': row['title'], 'member_ids': [str(m) for m in row['member_ids']],
|
||||
'created_at': format_time(row['created_at'])}
|
||||
|
||||
|
||||
def _message(row):
|
||||
return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'sender_id': str(row['sender_id']),
|
||||
'text': row['text'], 'attachment_ids': [str(x) for x in row['attachment_ids']],
|
||||
'created_at': format_time(row['created_at'])}
|
||||
|
||||
|
||||
def attachment(row):
|
||||
return {**{k: str(row[k]) for k in ('id', 'chat_id', 'owner_id')},
|
||||
**{k: row[k] for k in ('filename', 'content_type', 'size_bytes', 'sha256')},
|
||||
'status': 'ready', 'variants': [], 'error_code': None,
|
||||
'created_at': format_time(row['created_at']), 'updated_at': format_time(row['updated_at'])}
|
||||
|
||||
|
||||
def _page(rows, limit, convert):
|
||||
"""Из limit+1 строк: элементы страницы и ключ (created_at, id) последней, если есть продолжение."""
|
||||
items = rows[:limit]
|
||||
has_more = len(rows) > limit
|
||||
next_key = (to_micros(items[-1]['created_at']), str(items[-1]['id'])) if has_more else None
|
||||
return [convert(row) for row in items], next_key
|
||||
|
||||
|
||||
def _after(key):
|
||||
return from_micros(key[0]), uuid.UUID(key[1])
|
||||
|
||||
|
||||
class Repository:
|
||||
def __init__(self, pool):
|
||||
self._pool = pool
|
||||
|
||||
@contextmanager
|
||||
def _transaction(self):
|
||||
"""Соединение из пула в транзакции: COMMIT при успехе, ROLLBACK при исключении."""
|
||||
try:
|
||||
with self._pool.connection() as conn:
|
||||
yield conn
|
||||
except psycopg.OperationalError as error:
|
||||
# Нет соединения, пул исчерпан, истёк statement_timeout/lock_timeout — всё это 503.
|
||||
raise Unavailable('postgres') from error
|
||||
|
||||
def ping(self):
|
||||
with self._transaction() as conn:
|
||||
conn.execute('SELECT 1')
|
||||
|
||||
# --- пользователи -------------------------------------------------------
|
||||
|
||||
def create_user(self, username, display_name, password_hash):
|
||||
try:
|
||||
with self._transaction() as conn:
|
||||
row = conn.execute(
|
||||
'INSERT INTO users (id, username, display_name, password_hash) VALUES (%s, %s, %s, %s) '
|
||||
'RETURNING id, username, display_name, created_at',
|
||||
(uuid.uuid4(), username, display_name, password_hash),
|
||||
).fetchone()
|
||||
except errors.UniqueViolation:
|
||||
# Уникальность username гарантирует индекс БД, поэтому гонка двух регистраций безопасна.
|
||||
raise UsernameTaken
|
||||
return _user(row)
|
||||
|
||||
def get_user(self, user_id):
|
||||
with self._transaction() as conn:
|
||||
row = conn.execute(
|
||||
'SELECT id, username, display_name, created_at FROM users WHERE id = %s', (uuid.UUID(user_id),),
|
||||
).fetchone()
|
||||
return _user(row) if row else None
|
||||
|
||||
def get_credentials(self, username):
|
||||
"""(пользователь, хеш пароля) или (None, None)."""
|
||||
with self._transaction() as conn:
|
||||
row = conn.execute(
|
||||
'SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s',
|
||||
(username,),
|
||||
).fetchone()
|
||||
return (_user(row), row['password_hash']) if row else (None, None)
|
||||
|
||||
# --- чаты ---------------------------------------------------------------
|
||||
|
||||
def create_chat(self, title, member_ids):
|
||||
"""Чат и все участники одной транзакцией.
|
||||
|
||||
Неизвестный участник нарушает внешний ключ chat_members.user_id; тогда транзакция
|
||||
откатывается целиком и уже вставленная строка chats тоже исчезает.
|
||||
"""
|
||||
chat_id = uuid.uuid4()
|
||||
members = [uuid.UUID(member_id) for member_id in member_ids]
|
||||
try:
|
||||
with self._transaction() as conn:
|
||||
row = conn.execute(
|
||||
'INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING id, title, created_at', (chat_id, title),
|
||||
).fetchone()
|
||||
conn.execute(
|
||||
'INSERT INTO chat_members (chat_id, user_id, position) '
|
||||
'SELECT %s, member.user_id, member.ordinality - 1 '
|
||||
'FROM unnest(%s::uuid[]) WITH ORDINALITY AS member(user_id, ordinality)',
|
||||
(chat_id, members),
|
||||
)
|
||||
except errors.ForeignKeyViolation:
|
||||
log.info('event=chat_rolled_back reason=unknown_member')
|
||||
raise UnknownMember
|
||||
return _chat(dict(row, member_ids=members))
|
||||
|
||||
def get_chat(self, chat_id, user_id):
|
||||
"""Чат, если он есть и user_id в нём состоит; иначе None."""
|
||||
with self._transaction() as conn:
|
||||
row = conn.execute(
|
||||
'SELECT c.id, c.title, c.created_at, ' + MEMBER_IDS + ' FROM chats c '
|
||||
'WHERE c.id = %s AND EXISTS ('
|
||||
' SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)',
|
||||
(uuid.UUID(chat_id), uuid.UUID(user_id)),
|
||||
).fetchone()
|
||||
return _chat(row) if row else None
|
||||
|
||||
def list_chats(self, user_id, after, limit):
|
||||
select = ('SELECT c.id, c.title, c.created_at, ' + MEMBER_IDS + ' '
|
||||
'FROM chat_members me JOIN chats c ON c.id = me.chat_id WHERE me.user_id = %s ')
|
||||
order = 'ORDER BY c.created_at, c.id LIMIT %s'
|
||||
with self._transaction() as conn:
|
||||
if after is None:
|
||||
rows = conn.execute(select + order, (uuid.UUID(user_id), limit + 1)).fetchall()
|
||||
else:
|
||||
rows = conn.execute(select + 'AND (c.created_at, c.id) > (%s, %s) ' + order,
|
||||
(uuid.UUID(user_id), *_after(after), limit + 1)).fetchall()
|
||||
return _page(rows, limit, _chat)
|
||||
|
||||
# --- сообщения ----------------------------------------------------------
|
||||
|
||||
def add_message(self, chat_id, sender_id, text, key, request_hash, ttl_seconds, attachment_ids=()):
|
||||
"""Идемпотентная отправка: (сообщение, True если это повтор уже выполненного запроса).
|
||||
|
||||
Строка чата блокируется до конца транзакции. Поэтому, во-первых, сообщения одного чата
|
||||
записываются по очереди и created_at растёт в порядке фиксации: читатель, идущий по
|
||||
cursor, не пропустит сообщение, зафиксированное позже уже прочитанного. Во-вторых,
|
||||
одновременные запросы с одним ключом (область ключа включает путь чата) тоже идут по
|
||||
очереди, даже через разные реплики: второй увидит ключ первого и вернёт то же сообщение.
|
||||
Ключ и сообщение фиксируются одной транзакцией; при ошибке не остаётся ни того, ни другого.
|
||||
"""
|
||||
chat = uuid.UUID(chat_id)
|
||||
scope = (uuid.UUID(sender_id), 'POST', '/api/v1/chats/%s/messages' % chat_id, key)
|
||||
with self._transaction() as conn:
|
||||
conn.execute('SELECT 1 FROM chats WHERE id = %s FOR NO KEY UPDATE', (chat,))
|
||||
stored = conn.execute(
|
||||
'SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at, m.attachment_ids '
|
||||
'FROM idempotency_keys k JOIN messages m ON m.id = k.message_id '
|
||||
'WHERE k.user_id = %s AND k.method = %s AND k.path = %s AND k.key = %s '
|
||||
' AND k.created_at > clock_timestamp() - make_interval(secs => %s)',
|
||||
scope + (ttl_seconds,),
|
||||
).fetchone()
|
||||
if stored:
|
||||
if stored['request_hash'] != request_hash:
|
||||
raise IdempotencyConflict
|
||||
return _message(stored), True
|
||||
ids = [uuid.UUID(value) for value in attachment_ids]
|
||||
found = conn.execute('SELECT id FROM attachments WHERE chat_id = %s AND id = ANY(%s::uuid[])',
|
||||
(chat, ids)).fetchall()
|
||||
if len(found) != len(ids):
|
||||
raise not_found()
|
||||
row = conn.execute(
|
||||
'INSERT INTO messages (id, chat_id, sender_id, text, attachment_ids, created_at) '
|
||||
'VALUES (%s, %s, %s, %s, %s, GREATEST(clock_timestamp(), '
|
||||
" (SELECT max(created_at) FROM messages WHERE chat_id = %s) + interval '1 microsecond')) "
|
||||
'RETURNING id, chat_id, sender_id, text, created_at, attachment_ids',
|
||||
(uuid.uuid4(), chat, uuid.UUID(sender_id), text, ids, chat),
|
||||
).fetchone()
|
||||
for aid in ids:
|
||||
conn.execute('INSERT INTO message_attachments (message_id, attachment_id, chat_id) VALUES (%s,%s,%s)',
|
||||
(row['id'], aid, chat))
|
||||
# Устаревшая запись с тем же ключом (старше срока хранения) заменяется новой.
|
||||
conn.execute(
|
||||
'INSERT INTO idempotency_keys (user_id, method, path, key, request_hash, message_id) '
|
||||
'VALUES (%s, %s, %s, %s, %s, %s) '
|
||||
'ON CONFLICT (user_id, method, path, key) DO UPDATE SET request_hash = EXCLUDED.request_hash, '
|
||||
' message_id = EXCLUDED.message_id, created_at = EXCLUDED.created_at',
|
||||
scope + (request_hash, row['id']),
|
||||
)
|
||||
return _message(row), False
|
||||
|
||||
def delete_expired_idempotency_keys(self, ttl_seconds):
|
||||
"""Удаляет ключи старше срока хранения; возвращает число удалённых."""
|
||||
with self._transaction() as conn:
|
||||
return conn.execute(
|
||||
'DELETE FROM idempotency_keys WHERE created_at < clock_timestamp() - make_interval(secs => %s)',
|
||||
(ttl_seconds,),
|
||||
).rowcount
|
||||
|
||||
def list_messages(self, chat_id, after, limit):
|
||||
"""Страница истории. Запрос совпадает по форме с индексом messages_chat_history_idx."""
|
||||
select = 'SELECT id, chat_id, sender_id, text, created_at, attachment_ids FROM messages WHERE chat_id = %s '
|
||||
order = 'ORDER BY created_at, id LIMIT %s'
|
||||
with self._transaction() as conn:
|
||||
if after is None:
|
||||
rows = conn.execute(select + order, (uuid.UUID(chat_id), limit + 1)).fetchall()
|
||||
else:
|
||||
rows = conn.execute(select + 'AND (created_at, id) > (%s, %s) ' + order,
|
||||
(uuid.UUID(chat_id), *_after(after), limit + 1)).fetchall()
|
||||
return _page(rows, limit, _message)
|
||||
|
||||
def save_attachment(self, values, put):
|
||||
# Та же блокировка используется сборщиком orphan-объектов. Даже долгая пауза
|
||||
# между PUT и COMMIT не позволит сборщику удалить загружаемый объект.
|
||||
with self._transaction() as conn:
|
||||
conn.execute('SELECT pg_advisory_xact_lock(hashtextextended(%s, 0))', (values['object_key'],))
|
||||
put()
|
||||
row = conn.execute(
|
||||
'INSERT INTO attachments (id, chat_id, owner_id, object_key, filename, content_type, size_bytes, sha256) '
|
||||
'VALUES (%(id)s,%(chat_id)s,%(owner_id)s,%(object_key)s,%(filename)s,%(content_type)s,%(size_bytes)s,%(sha256)s) '
|
||||
'RETURNING *', values).fetchone()
|
||||
return attachment(row)
|
||||
|
||||
def get_attachment(self, attachment_id, user_id):
|
||||
with self._transaction() as conn:
|
||||
row = conn.execute(
|
||||
'SELECT a.* FROM attachments a JOIN chat_members m ON m.chat_id=a.chat_id '
|
||||
'WHERE a.id=%s AND m.user_id=%s', (uuid.UUID(attachment_id), uuid.UUID(user_id))).fetchone()
|
||||
return row
|
||||
@@ -0,0 +1,29 @@
|
||||
"""Ошибки, которые HTTP-слой превращает в ответы контракта."""
|
||||
|
||||
|
||||
class ApiError(Exception):
|
||||
"""Ответ с ошибкой в формате {"error": {...}}; challenge — значение WWW-Authenticate для 401."""
|
||||
|
||||
def __init__(self, status, code, message, challenge=None):
|
||||
super().__init__(message)
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
self.challenge = challenge
|
||||
|
||||
|
||||
class Unavailable(Exception):
|
||||
"""Хранилище (postgres или valkey) не ответило в срок; клиент получит 503."""
|
||||
|
||||
def __init__(self, dependency):
|
||||
super().__init__(dependency)
|
||||
self.dependency = dependency
|
||||
|
||||
|
||||
def bad_request(message):
|
||||
return ApiError(400, 'invalid_request', message)
|
||||
|
||||
|
||||
def not_found():
|
||||
# Чужой объект неотличим от несуществующего.
|
||||
return ApiError(404, 'not_found', 'Объект не найден')
|
||||
@@ -0,0 +1,26 @@
|
||||
"""Проверка для Docker HEALTHCHECK: python -m messenger.healthcheck.
|
||||
|
||||
В slim-образе нет curl, поэтому готовность проверяется самим интерпретатором.
|
||||
Код возврата 0 — контейнер healthy, 1 — unhealthy.
|
||||
"""
|
||||
import http.client
|
||||
import os
|
||||
import sys
|
||||
|
||||
|
||||
def main():
|
||||
try:
|
||||
connection = http.client.HTTPConnection('127.0.0.1', int(os.environ.get('APP_PORT', '8080')), timeout=2)
|
||||
try:
|
||||
connection.request('GET', '/health/ready', headers={'Connection': 'close'})
|
||||
response = connection.getresponse()
|
||||
response.read() # дочитываем ответ, чтобы соединение закрылось штатно, а не обрывом
|
||||
return 0 if response.status == 200 else 1
|
||||
finally:
|
||||
connection.close()
|
||||
except (OSError, ValueError, http.client.HTTPException):
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,29 @@
|
||||
"""Декодирование в отдельном процессе: RAM освобождается при выходе, время ограничено родителем."""
|
||||
import sys
|
||||
import warnings
|
||||
|
||||
from PIL import Image, UnidentifiedImageError
|
||||
|
||||
|
||||
def main():
|
||||
path, expected, pixels = sys.argv[1:]
|
||||
Image.MAX_IMAGE_PIXELS = int(pixels)
|
||||
warnings.simplefilter('error', Image.DecompressionBombWarning)
|
||||
try:
|
||||
with Image.open(path, formats=['PNG', 'JPEG']) as image:
|
||||
if image.width * image.height > int(pixels):
|
||||
return 13
|
||||
if Image.MIME[image.format] != expected:
|
||||
return 15
|
||||
image.verify()
|
||||
with Image.open(path, formats=['PNG', 'JPEG']) as image:
|
||||
image.load() # verify одного JPEG недостаточно: проверяем и распаковку.
|
||||
return 0
|
||||
except (Image.DecompressionBombWarning, Image.DecompressionBombError):
|
||||
return 13
|
||||
except (OSError, ValueError, SyntaxError, UnidentifiedImageError):
|
||||
return 15
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,77 @@
|
||||
"""Миграции схемы: python -m messenger.migrate.
|
||||
|
||||
Файлы migrations/NNNN_*.sql применяются по порядку номеров, каждый в своей транзакции.
|
||||
Применённые версии и контрольные суммы записываются в schema_migrations, поэтому повторный
|
||||
запуск ничего не дублирует. Изменение уже применённого файла останавливает запуск: менять
|
||||
схему нужно новым файлом. Advisory lock не даёт двум процессам применять миграции одновременно.
|
||||
"""
|
||||
import hashlib
|
||||
import logging
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
import psycopg
|
||||
|
||||
from .config import read_secret
|
||||
|
||||
log = logging.getLogger('messenger.migrate')
|
||||
|
||||
MIGRATIONS_DIR = Path(__file__).resolve().parents[1] / 'migrations'
|
||||
LOCK_ID = 2026_0002 # произвольная константа для pg_advisory_lock
|
||||
|
||||
CREATE_TABLE = '''
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
checksum text NOT NULL,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
)'''
|
||||
|
||||
|
||||
def _read(path):
|
||||
# Окончания строк нормализуются: checkout в Windows (CRLF) не должен менять контрольную сумму.
|
||||
sql = path.read_text(encoding='utf-8').replace('\r\n', '\n')
|
||||
return sql, hashlib.sha256(sql.encode('utf-8')).hexdigest()
|
||||
|
||||
|
||||
def migrate(database_url, directory=MIGRATIONS_DIR):
|
||||
files = sorted(directory.glob('[0-9][0-9][0-9][0-9]_*.sql'))
|
||||
if not files:
|
||||
raise SystemExit('Нет файлов миграций в ' + str(directory))
|
||||
applied_now = 0
|
||||
with psycopg.connect(database_url, autocommit=True, connect_timeout=5) as conn:
|
||||
conn.execute('SELECT pg_advisory_lock(%s)', (LOCK_ID,))
|
||||
try:
|
||||
conn.execute(CREATE_TABLE)
|
||||
applied = dict(conn.execute('SELECT version, checksum FROM schema_migrations').fetchall())
|
||||
for path in files:
|
||||
version = path.stem
|
||||
sql, checksum = _read(path)
|
||||
if version in applied:
|
||||
if applied[version] != checksum:
|
||||
raise SystemExit('Миграция %s изменена после применения: добавьте новую вместо правки' % version)
|
||||
continue
|
||||
started = time.monotonic()
|
||||
with conn.transaction():
|
||||
conn.execute(sql)
|
||||
conn.execute('INSERT INTO schema_migrations (version, checksum) VALUES (%s, %s)', (version, checksum))
|
||||
applied_now += 1
|
||||
log.info('event=migration_applied version=%s duration_ms=%.0f', version, (time.monotonic() - started) * 1000)
|
||||
finally:
|
||||
conn.execute('SELECT pg_advisory_unlock(%s)', (LOCK_ID,))
|
||||
log.info('event=migrations_done applied_now=%d total=%d', applied_now, len(files))
|
||||
|
||||
|
||||
def main():
|
||||
logging.basicConfig(stream=sys.stdout, level=logging.INFO, format='%(levelname)s %(message)s')
|
||||
try:
|
||||
migrate(read_secret('DATABASE_URL'))
|
||||
except psycopg.Error as error:
|
||||
# Сообщения psycopg не содержат пароль, а первая строка объясняет причину.
|
||||
log.error('event=migration_failed error=%s detail=%s', type(error).__name__, str(error).splitlines()[0][:300])
|
||||
return 1
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,40 @@
|
||||
"""Приватный S3; ограниченные таймауты и отсутствие скрытых повторов PUT."""
|
||||
import os
|
||||
|
||||
import boto3
|
||||
from botocore.config import Config
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
|
||||
from .config import read_secret
|
||||
from .errors import Unavailable
|
||||
|
||||
|
||||
class ObjectStore:
|
||||
def __init__(self, admin=False):
|
||||
self.bucket = os.environ.get('S3_BUCKET', 'messenger-attachments')
|
||||
prefix = 'S3_ADMIN_' if admin else 'S3_'
|
||||
self.client = boto3.client(
|
||||
's3', endpoint_url=os.environ.get('S3_ENDPOINT', 'http://s3:9000'),
|
||||
region_name=os.environ.get('S3_REGION', 'us-east-1'),
|
||||
aws_access_key_id=read_secret(prefix + 'ACCESS_KEY_ID'),
|
||||
aws_secret_access_key=read_secret(prefix + 'SECRET_ACCESS_KEY'),
|
||||
config=Config(connect_timeout=1, read_timeout=3, max_pool_connections=16,
|
||||
retries={'total_max_attempts': 1}, s3={'addressing_style': 'path'},
|
||||
request_checksum_calculation='when_required',
|
||||
response_checksum_validation='when_required'))
|
||||
|
||||
def call(self, method, **kwargs):
|
||||
try:
|
||||
return getattr(self.client, method)(Bucket=self.bucket, **kwargs)
|
||||
except (BotoCoreError, ClientError, OSError) as error:
|
||||
raise Unavailable('s3') from error
|
||||
|
||||
def ping(self):
|
||||
self.call('head_bucket')
|
||||
|
||||
def put(self, key, file, size, content_type):
|
||||
file.seek(0)
|
||||
self.call('put_object', Key=key, Body=file, ContentLength=size, ContentType=content_type)
|
||||
|
||||
def get(self, key):
|
||||
return self.call('get_object', Key=key)['Body']
|
||||
@@ -0,0 +1,50 @@
|
||||
"""Хеширование паролей: Argon2id из библиотеки argon2-cffi.
|
||||
|
||||
Хеш хранит алгоритм, параметры и соль в одной строке вида $argon2id$v=19$m=...,t=...,p=...$соль$хеш.
|
||||
"""
|
||||
import secrets
|
||||
import threading
|
||||
from contextlib import contextmanager
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import InvalidHashError, VerificationError
|
||||
|
||||
from .errors import Unavailable
|
||||
|
||||
# Минимальные параметры из OWASP Password Storage Cheat Sheet: 19 МиБ памяти, 2 прохода, 1 поток.
|
||||
_hasher = PasswordHasher(time_cost=2, memory_cost=19 * 1024, parallelism=1)
|
||||
|
||||
# Каждый расчёт занимает 19 МиБ памяти. Одновременно считаем не больше 4 хешей на процесс,
|
||||
# чтобы пик памяти реплики был предсказуем при лимите контейнера (compose.yaml, 256 МБ).
|
||||
# Остальные запросы ждут очереди; дольше 5 с — ответ 503 вместо бесконечного ожидания.
|
||||
MAX_CONCURRENT_HASHES = 4
|
||||
_slots = threading.BoundedSemaphore(MAX_CONCURRENT_HASHES)
|
||||
|
||||
# Хеш случайного пароля. Проверка против него для несуществующего username занимает
|
||||
# столько же времени, сколько обычная: по задержке ответа нельзя узнать, есть ли пользователь.
|
||||
_DUMMY_HASH = _hasher.hash(secrets.token_hex(16))
|
||||
|
||||
|
||||
@contextmanager
|
||||
def _slot():
|
||||
if not _slots.acquire(timeout=5):
|
||||
raise Unavailable('password-hashing')
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
_slots.release()
|
||||
|
||||
|
||||
def hash_password(password):
|
||||
with _slot():
|
||||
return _hasher.hash(password)
|
||||
|
||||
|
||||
def verify_password(password_hash, password):
|
||||
"""True, если пароль подходит к хешу; при password_hash=None всегда False за то же время."""
|
||||
with _slot():
|
||||
try:
|
||||
_hasher.verify(password_hash or _DUMMY_HASH, password)
|
||||
except (VerificationError, InvalidHashError):
|
||||
return False
|
||||
return password_hash is not None
|
||||
@@ -0,0 +1,489 @@
|
||||
"""HTTP-слой: маршрутизация, аутентификация, ответы в формате контракта, логи запросов."""
|
||||
import json
|
||||
import hashlib
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from urllib.parse import parse_qs
|
||||
|
||||
from . import validation
|
||||
from .db import IdempotencyConflict, UnknownMember, UsernameTaken
|
||||
from .errors import ApiError, Unavailable, bad_request, not_found
|
||||
from .passwords import hash_password, verify_password
|
||||
from .timeutil import format_time
|
||||
from .db import attachment
|
||||
|
||||
log = logging.getLogger('messenger')
|
||||
|
||||
# Сообщение в 4000 символов даже в виде \uXXXX-последовательностей меньше 64 КиБ.
|
||||
MAX_BODY_BYTES = 64 * 1024
|
||||
# Тело до этого размера дочитывается ради аккуратного 413; больше — соединение просто закрывается.
|
||||
MAX_DISCARD_BYTES = 1024 * 1024
|
||||
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
|
||||
CHAT = r'/api/v1/chats/(?P<chat_id>[^/]+)'
|
||||
ROUTES = tuple((method, re.compile(pattern), handler) for method, pattern, handler in (
|
||||
('GET', r'/health/live', '_live'),
|
||||
('GET', r'/health/ready', '_ready'),
|
||||
('POST', r'/api/v1/users', '_create_user'),
|
||||
('GET', r'/api/v1/users/me', '_current_user'),
|
||||
('POST', r'/api/v1/auth/sessions', '_create_session'),
|
||||
('DELETE', r'/api/v1/auth/sessions/current', '_delete_session'),
|
||||
('POST', r'/api/v1/chats', '_create_chat'),
|
||||
('GET', r'/api/v1/chats', '_list_chats'),
|
||||
('GET', CHAT, '_get_chat'),
|
||||
('POST', CHAT + r'/messages', '_create_message'),
|
||||
('GET', CHAT + r'/messages', '_list_messages'),
|
||||
('POST', CHAT + r'/attachments', '_upload'),
|
||||
('GET', r'/api/v1/attachments/(?P<attachment_id>[^/]+)', '_attachment'),
|
||||
('GET', r'/api/v1/attachments/(?P<attachment_id>[^/]+)/content', '_content'),
|
||||
))
|
||||
|
||||
|
||||
class Download:
|
||||
def __init__(self, stream, row):
|
||||
self.stream, self.row = stream, row
|
||||
|
||||
|
||||
class MessengerServer(ThreadingHTTPServer):
|
||||
"""Поток на соединение; считает выполняющиеся запросы для плавной остановки."""
|
||||
|
||||
# Потоки-демоны не держат процесс: срок остановки ограничивает wait_idle().
|
||||
daemon_threads = True
|
||||
# Очередь соединений по умолчанию (5) мала для десятков одновременных клиентов.
|
||||
request_queue_size = 128
|
||||
|
||||
def __init__(self, address, repo, sessions, instance_id, idempotency_ttl, objects):
|
||||
super().__init__(address, RequestHandler)
|
||||
self.repo = repo
|
||||
self.sessions = sessions
|
||||
self.instance_id = instance_id
|
||||
self.idempotency_ttl = idempotency_ttl
|
||||
self.objects = objects
|
||||
# Один декодер на реплику: 40M RGBA <=160 MB + память интерпретаторов.
|
||||
self.upload_slots = threading.BoundedSemaphore(1)
|
||||
self.max_upload = int(os.environ.get('MAX_UPLOAD_BYTES', '10485760'))
|
||||
self.max_pixels = int(os.environ.get('MAX_IMAGE_PIXELS', '40000000'))
|
||||
if not 1 <= self.max_upload <= 10485760 or not 1 <= self.max_pixels <= 40000000:
|
||||
raise ValueError('Некорректный лимит вложений')
|
||||
self._state = threading.Condition()
|
||||
self._active = 0
|
||||
self._draining = False
|
||||
self.ready = True
|
||||
|
||||
def begin_not_ready(self):
|
||||
"""Первый шаг остановки: /health/ready отвечает 503, остальные запросы ещё обслуживаются.
|
||||
|
||||
Балансировщик видит это при следующих проверках и перестаёт присылать сюда запросы.
|
||||
"""
|
||||
self.ready = False
|
||||
|
||||
def try_begin_request(self):
|
||||
"""False, если сервер уже останавливается и запрос принимать нельзя."""
|
||||
with self._state:
|
||||
if self._draining:
|
||||
return False
|
||||
self._active += 1
|
||||
return True
|
||||
|
||||
def end_request(self):
|
||||
with self._state:
|
||||
self._active -= 1
|
||||
self._state.notify_all()
|
||||
|
||||
def begin_drain(self):
|
||||
with self._state:
|
||||
self._draining = True
|
||||
|
||||
def wait_idle(self, timeout):
|
||||
"""Ждёт завершения начатых запросов; True, если успели за timeout секунд."""
|
||||
with self._state:
|
||||
return self._state.wait_for(lambda: self._active == 0, timeout)
|
||||
|
||||
def handle_error(self, request, client_address):
|
||||
# Обрыв соединения клиентом — обычная ситуация, а не ошибка сервера: без traceback.
|
||||
error = sys.exc_info()[0]
|
||||
level = logging.DEBUG if issubclass(error, ConnectionError) else logging.WARNING
|
||||
log.log(level, 'event=connection_error error=%s', error.__name__)
|
||||
|
||||
|
||||
class RequestHandler(BaseHTTPRequestHandler):
|
||||
protocol_version = 'HTTP/1.1'
|
||||
# Секунды ожидания данных от клиента: зависшее соединение не занимает поток вечно.
|
||||
timeout = 15
|
||||
|
||||
def do_GET(self):
|
||||
self._handle()
|
||||
|
||||
do_POST = do_PUT = do_PATCH = do_DELETE = do_HEAD = do_OPTIONS = do_GET
|
||||
|
||||
# --- общий путь запроса -------------------------------------------------
|
||||
|
||||
def _handle(self):
|
||||
started = time.monotonic()
|
||||
self.request_id = uuid.uuid4().hex
|
||||
self.user_id = '-'
|
||||
path, _, query = self.path.partition('?')
|
||||
status = 0 # 0 в логе: ответ отправить не удалось
|
||||
accepted = self.server.try_begin_request()
|
||||
try:
|
||||
if accepted:
|
||||
status, payload, headers = self._process(path, query)
|
||||
else:
|
||||
self.close_connection = True
|
||||
status, payload, headers = self._error(ApiError(503, 'unavailable', 'Сервер завершает работу'))
|
||||
self._send(status, payload, headers)
|
||||
except OSError:
|
||||
status = 0
|
||||
self.close_connection = True
|
||||
finally:
|
||||
if accepted:
|
||||
self.server.end_request()
|
||||
# В лог попадают только метаданные: тела запросов, тексты сообщений, пароли и токены не пишутся.
|
||||
log.log(
|
||||
logging.DEBUG if path.startswith('/health/') else logging.INFO,
|
||||
'request_id=%s method=%s path=%s status=%d duration_ms=%.1f user_id=%s',
|
||||
self.request_id, self.command, re.sub(r'[^\x21-\x7e]', '?', path)[:200], status,
|
||||
(time.monotonic() - started) * 1000, self.user_id,
|
||||
)
|
||||
|
||||
def _process(self, path, query):
|
||||
"""(статус, тело или None, дополнительные заголовки)."""
|
||||
try:
|
||||
upload = self.command == 'POST' and re.fullmatch(CHAT + r'/attachments', path)
|
||||
if upload:
|
||||
# До чтения файла проверяем токен и чат. При ошибке непрочитанное тело
|
||||
# не должно интерпретироваться как следующий запрос keep-alive.
|
||||
self.close_connection = True
|
||||
body = b'' if upload else self._read_body()
|
||||
for method, pattern, handler in ROUTES:
|
||||
match = pattern.fullmatch(path)
|
||||
if match and method == self.command:
|
||||
params = parse_qs(query, keep_blank_values=True)
|
||||
status, payload = getattr(self, handler)(body, params, **match.groupdict())
|
||||
return status, payload, ()
|
||||
raise ApiError(404, 'not_found', 'Маршрут не найден')
|
||||
except ApiError as error:
|
||||
return self._error(error)
|
||||
except Unavailable as error:
|
||||
log.warning('event=dependency_unavailable request_id=%s dependency=%s error=%s',
|
||||
self.request_id, error.dependency, type(error.__cause__).__name__)
|
||||
return self._error(ApiError(503, 'unavailable', 'Сервис временно недоступен: ' + error.dependency))
|
||||
except Exception:
|
||||
log.exception('event=unhandled_error request_id=%s', self.request_id)
|
||||
return self._error(ApiError(500, 'internal_error', 'Внутренняя ошибка сервера'))
|
||||
|
||||
def _read_body(self):
|
||||
"""Читает тело целиком до маршрутизации, чтобы keep-alive поток не сбился."""
|
||||
header = self.headers.get('Content-Length')
|
||||
if header is None:
|
||||
if self.headers.get('Transfer-Encoding'):
|
||||
self.close_connection = True
|
||||
raise bad_request('Нужен заголовок Content-Length')
|
||||
return b''
|
||||
if not re.fullmatch(r'[0-9]{1,18}', header):
|
||||
self.close_connection = True
|
||||
raise bad_request('Некорректный Content-Length')
|
||||
length = int(header)
|
||||
if length > MAX_BODY_BYTES:
|
||||
self.close_connection = True
|
||||
if length <= MAX_DISCARD_BYTES:
|
||||
self._discard(length)
|
||||
raise ApiError(413, 'payload_too_large', 'Тело запроса больше %d байт' % MAX_BODY_BYTES)
|
||||
try:
|
||||
body = self.rfile.read(length)
|
||||
except OSError: # таймаут или обрыв соединения
|
||||
body = b''
|
||||
if len(body) != length:
|
||||
self.close_connection = True
|
||||
raise bad_request('Тело запроса получено не полностью')
|
||||
return body
|
||||
|
||||
def _discard(self, remaining):
|
||||
"""Дочитывает слишком большое тело по частям, не храня его в памяти.
|
||||
|
||||
Если закрыть соединение с непрочитанными данными, клиент получит обрыв
|
||||
вместо ответа 413.
|
||||
"""
|
||||
try:
|
||||
while remaining > 0:
|
||||
chunk = self.rfile.read(min(remaining, 64 * 1024))
|
||||
if not chunk:
|
||||
break
|
||||
remaining -= len(chunk)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
def _error(self, error):
|
||||
payload = {'error': {'code': error.code, 'message': error.message, 'request_id': self.request_id}}
|
||||
headers = (('WWW-Authenticate', error.challenge),) if error.challenge else ()
|
||||
return error.status, payload, headers
|
||||
|
||||
def _send(self, status, payload, headers=()):
|
||||
"""Ответ с JSON-телом; payload=None — ответ без тела (204)."""
|
||||
if isinstance(payload, Download):
|
||||
with payload.stream as stream:
|
||||
self.send_response(status)
|
||||
self.send_header('Content-Type', payload.row['content_type'])
|
||||
self.send_header('Content-Length', str(payload.row['size_bytes']))
|
||||
self.send_header('X-Request-Id', self.request_id)
|
||||
self.send_header('X-Instance-Id', self.server.instance_id)
|
||||
self.send_header('X-Content-Type-Options', 'nosniff')
|
||||
self.send_header('Cache-Control', 'private, no-store')
|
||||
self.end_headers()
|
||||
if self.command != 'HEAD':
|
||||
while chunk := stream.read(64 * 1024):
|
||||
self.wfile.write(chunk)
|
||||
return
|
||||
body = b'' if payload is None else json.dumps(payload, ensure_ascii=False, separators=(',', ':')).encode('utf-8')
|
||||
self.send_response(status)
|
||||
if payload is not None:
|
||||
self.send_header('Content-Type', 'application/json; charset=utf-8')
|
||||
self.send_header('Content-Length', str(len(body)))
|
||||
self.send_header('X-Request-Id', self.request_id)
|
||||
# Какая реплика ответила: имя контейнера, стабильно для жизни процесса.
|
||||
self.send_header('X-Instance-Id', self.server.instance_id)
|
||||
for name, value in headers:
|
||||
self.send_header(name, value)
|
||||
if self.close_connection:
|
||||
self.send_header('Connection', 'close')
|
||||
self.end_headers()
|
||||
if body and self.command != 'HEAD':
|
||||
self.wfile.write(body)
|
||||
|
||||
def send_error(self, code, message=None, explain=None):
|
||||
"""Ошибки разбора HTTP (до маршрутизации) — тоже в общем формате ошибок."""
|
||||
self.request_id = uuid.uuid4().hex
|
||||
self.close_connection = True
|
||||
if code == 501: # метод, которого нет в API
|
||||
error = ApiError(404, 'not_found', 'Маршрут не найден')
|
||||
else:
|
||||
error = bad_request('Некорректный HTTP-запрос')
|
||||
self._send(*self._error(error))
|
||||
log.info('request_id=%s event=http_parse_error http_status=%d status=%d', self.request_id, code, error.status)
|
||||
|
||||
def version_string(self):
|
||||
return 'messenger' # заголовок Server без версии Python
|
||||
|
||||
def log_request(self, code='-', size='-'):
|
||||
pass # запрос логируется один раз в _handle
|
||||
|
||||
def log_message(self, format, *args):
|
||||
log.debug('event=http_server detail=%s', format % args)
|
||||
|
||||
# --- общие проверки -----------------------------------------------------
|
||||
|
||||
def _authenticate(self):
|
||||
"""user_id владельца Bearer-токена. X-User-Id и Basic здесь не принимаются.
|
||||
|
||||
Если Valkey недоступен, sessions.user_id бросает Unavailable и клиент получает 503:
|
||||
запрос не продолжается как анонимный.
|
||||
"""
|
||||
token = validation.parse_bearer(self.headers.get('Authorization'))
|
||||
user_id = self.server.sessions.user_id(token) if token else None
|
||||
if user_id is None:
|
||||
raise ApiError(401, 'unauthorized', 'Нужен действующий токен: Authorization: Bearer <token>',
|
||||
challenge=BEARER_CHALLENGE)
|
||||
self.token = token
|
||||
self.user_id = user_id
|
||||
return user_id
|
||||
|
||||
def _accessible_chat(self, user_id, raw_chat_id):
|
||||
chat_id = validation.parse_uuid(raw_chat_id)
|
||||
if chat_id is None:
|
||||
raise bad_request('chat_id должен быть UUID')
|
||||
chat = self.server.repo.get_chat(chat_id, user_id)
|
||||
if chat is None:
|
||||
raise not_found()
|
||||
return chat
|
||||
|
||||
def _json_body(self, body):
|
||||
if self.headers.get_content_type() != 'application/json':
|
||||
raise bad_request('Content-Type должен быть application/json')
|
||||
return body
|
||||
|
||||
# --- обработчики маршрутов ----------------------------------------------
|
||||
|
||||
def _live(self, body, query):
|
||||
return 200, {'status': 'ok'}
|
||||
|
||||
def _ready(self, body, query):
|
||||
# После SIGTERM реплика сначала перестаёт быть готовой, чтобы балансировщик её исключил.
|
||||
if not self.server.ready:
|
||||
raise ApiError(503, 'unavailable', 'Реплика завершает работу')
|
||||
# Обязательный путь API требует обоих хранилищ: без БД нет данных, без Valkey — сессий.
|
||||
self.server.repo.ping()
|
||||
self.server.sessions.ping()
|
||||
self.server.objects.ping()
|
||||
return 200, {'status': 'ok'}
|
||||
|
||||
def _create_user(self, body, query):
|
||||
username, display_name, password = validation.parse_create_user(self._json_body(body))
|
||||
try:
|
||||
return 201, self.server.repo.create_user(username, display_name, hash_password(password))
|
||||
except UsernameTaken:
|
||||
raise ApiError(409, 'conflict', 'Пользователь с таким username уже существует')
|
||||
|
||||
def _create_session(self, body, query):
|
||||
"""Вход: только Authorization: Basic. Ответ 401 одинаковый для любой ошибки входа."""
|
||||
if body:
|
||||
raise bad_request('Тело не нужно: логин и пароль передаются в Authorization: Basic')
|
||||
credentials = validation.parse_basic(self.headers.get('Authorization'))
|
||||
user = None
|
||||
if credentials:
|
||||
username, password = credentials
|
||||
user, password_hash = self.server.repo.get_credentials(username)
|
||||
# Для несуществующего username проверка идёт против фиктивного хеша за то же время.
|
||||
if not verify_password(password_hash, password):
|
||||
user = None
|
||||
if user is None:
|
||||
raise ApiError(401, 'unauthorized', 'Неверный логин или пароль', challenge=BASIC_CHALLENGE)
|
||||
token, expires_at = self.server.sessions.create(user['id'])
|
||||
self.user_id = user['id']
|
||||
return 201, {'token': token, 'token_type': 'Bearer', 'expires_at': format_time(expires_at), 'user': user}
|
||||
|
||||
def _delete_session(self, body, query):
|
||||
self._authenticate()
|
||||
if not self.server.sessions.revoke(self.token):
|
||||
# Сессия истекла между проверкой и удалением.
|
||||
raise ApiError(401, 'unauthorized', 'Сессия уже недействительна', challenge=BEARER_CHALLENGE)
|
||||
return 204, None
|
||||
|
||||
def _current_user(self, body, query):
|
||||
user = self.server.repo.get_user(self._authenticate())
|
||||
if user is None:
|
||||
raise ApiError(401, 'unauthorized', 'Пользователь сессии не найден', challenge=BEARER_CHALLENGE)
|
||||
return 200, user
|
||||
|
||||
def _create_chat(self, body, query):
|
||||
user_id = self._authenticate()
|
||||
title, member_ids = validation.parse_create_chat(self._json_body(body))
|
||||
if user_id not in member_ids:
|
||||
raise bad_request('member_ids должен включать вызывающего пользователя')
|
||||
try:
|
||||
return 201, self.server.repo.create_chat(title, member_ids)
|
||||
except UnknownMember:
|
||||
raise bad_request('member_ids содержит неизвестного пользователя')
|
||||
|
||||
def _list_chats(self, body, query):
|
||||
user_id = self._authenticate()
|
||||
scope = 'chats:' + user_id
|
||||
limit = validation.parse_limit(query)
|
||||
after = validation.parse_cursor(query, scope)
|
||||
items, next_key = self.server.repo.list_chats(user_id, after, limit)
|
||||
return 200, {'items': items, 'next_cursor': validation.encode_cursor(scope, next_key)}
|
||||
|
||||
def _get_chat(self, body, query, chat_id):
|
||||
return 200, self._accessible_chat(self._authenticate(), chat_id)
|
||||
|
||||
def _create_message(self, body, query, chat_id):
|
||||
# Повтор с тем же ключом снова проходит аутентификацию и проверку доступа.
|
||||
user_id = self._authenticate()
|
||||
chat = self._accessible_chat(user_id, chat_id)
|
||||
key = validation.parse_idempotency_key(self.headers.get('Idempotency-Key'))
|
||||
text, ids = validation.parse_create_message(self._json_body(body))
|
||||
try:
|
||||
message, replayed = self.server.repo.add_message(
|
||||
chat['id'], user_id, text, key, validation.request_fingerprint(text, ids), self.server.idempotency_ttl, ids)
|
||||
except IdempotencyConflict:
|
||||
raise ApiError(409, 'conflict', 'Этот Idempotency-Key уже использован с другим телом запроса')
|
||||
if replayed:
|
||||
log.info('event=idempotent_replay request_id=%s message_id=%s', self.request_id, message['id'])
|
||||
return 201, message
|
||||
|
||||
def _list_messages(self, body, query, chat_id):
|
||||
chat = self._accessible_chat(self._authenticate(), chat_id)
|
||||
scope = 'messages:' + chat['id']
|
||||
limit = validation.parse_limit(query)
|
||||
after = validation.parse_cursor(query, scope)
|
||||
items, next_key = self.server.repo.list_messages(chat['id'], after, limit)
|
||||
return 200, {'items': items, 'next_cursor': validation.encode_cursor(scope, next_key)}
|
||||
|
||||
def _upload(self, body, query, chat_id):
|
||||
user_id = self._authenticate()
|
||||
chat = self._accessible_chat(user_id, chat_id)
|
||||
filename = validation._single(query, 'filename')
|
||||
if (not filename or not filename.strip() or len(filename) > 255
|
||||
or any(c in '/\\' or ord(c) < 32 or 127 <= ord(c) <= 159 for c in filename)):
|
||||
raise bad_request('filename: безопасное имя из 1–255 символов без путей и управляющих символов')
|
||||
try:
|
||||
filename.encode('utf-8')
|
||||
except UnicodeEncodeError:
|
||||
raise bad_request('Некорректный filename')
|
||||
mime = self.headers.get_content_type()
|
||||
if mime not in ('image/png', 'image/jpeg'):
|
||||
raise ApiError(415, 'unsupported_media_type', 'Допустимы PNG и JPEG')
|
||||
lengths = self.headers.get_all('Content-Length', [])
|
||||
if self.headers.get('Transfer-Encoding') or len(lengths) != 1 or not re.fullmatch(r'[0-9]{1,18}', lengths[0]):
|
||||
raise bad_request('Нужен один корректный Content-Length')
|
||||
length = int(lengths[0])
|
||||
if length > self.server.max_upload:
|
||||
raise ApiError(413, 'payload_too_large', 'Максимум 10 MiB')
|
||||
if not self.server.upload_slots.acquire(timeout=8):
|
||||
raise ApiError(503, 'unavailable', 'Загрузки заняты; повторите позже')
|
||||
try:
|
||||
# Ограниченный временный диск контейнера; оригиналы здесь не сохраняются.
|
||||
with tempfile.TemporaryDirectory(prefix='upload-') as directory:
|
||||
path = os.path.join(directory, 'original')
|
||||
digest = hashlib.sha256()
|
||||
deadline = time.monotonic() + 10
|
||||
with open(path, 'w+b') as file:
|
||||
remaining = length
|
||||
while remaining:
|
||||
self.connection.settimeout(max(0.1, deadline - time.monotonic()))
|
||||
chunk = self.rfile.read1(min(remaining, 64 * 1024))
|
||||
if not chunk or time.monotonic() > deadline:
|
||||
raise bad_request('Загрузка не завершена в срок')
|
||||
file.write(chunk)
|
||||
digest.update(chunk)
|
||||
remaining -= len(chunk)
|
||||
file.flush()
|
||||
try:
|
||||
result = subprocess.run([sys.executable, '-m', 'messenger.image_check', path,
|
||||
mime, str(self.server.max_pixels)], timeout=8,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
except subprocess.TimeoutExpired:
|
||||
raise ApiError(415, 'unsupported_media_type', 'Изображение не удалось проверить в срок')
|
||||
if result.returncode == 13:
|
||||
raise ApiError(413, 'payload_too_large', 'Слишком много пикселей')
|
||||
if result.returncode:
|
||||
raise ApiError(415, 'unsupported_media_type', 'Повреждённое изображение или неверный MIME')
|
||||
aid = uuid.uuid4()
|
||||
values = dict(id=aid, chat_id=uuid.UUID(chat['id']), owner_id=uuid.UUID(user_id),
|
||||
object_key='originals/' + aid.hex, filename=filename, content_type=mime,
|
||||
size_bytes=length, sha256=digest.hexdigest())
|
||||
saved = self.server.repo.save_attachment(
|
||||
values, lambda: self.server.objects.put(values['object_key'], file, length, mime))
|
||||
return 201, saved
|
||||
except (TimeoutError, ConnectionError):
|
||||
raise bad_request('Загрузка прервана или превышено время ожидания')
|
||||
finally:
|
||||
self.server.upload_slots.release()
|
||||
|
||||
def _accessible_attachment(self, raw_id):
|
||||
user_id = self._authenticate()
|
||||
aid = validation.parse_uuid(raw_id)
|
||||
if aid is None:
|
||||
raise bad_request('attachment_id должен быть UUID')
|
||||
row = self.server.repo.get_attachment(aid, user_id)
|
||||
if row is None:
|
||||
raise not_found()
|
||||
return row
|
||||
|
||||
def _attachment(self, body, query, attachment_id):
|
||||
return 200, attachment(self._accessible_attachment(attachment_id))
|
||||
|
||||
def _content(self, body, query, attachment_id):
|
||||
row = self._accessible_attachment(attachment_id)
|
||||
if validation._single(query, 'variant') not in (None, 'original'):
|
||||
raise not_found()
|
||||
return 200, Download(self.server.objects.get(row['object_key']), row)
|
||||
@@ -0,0 +1,81 @@
|
||||
"""Сессии в Valkey — единственное хранилище сессий.
|
||||
|
||||
Ключ: session:<sha256 от токена>, значение: JSON с user_id и сроком. Срок задаётся абсолютным
|
||||
временем (PXAT), поэтому перезапуск ничего не продлевает. Сохранность при рестарте
|
||||
обеспечивает AOF с fsync на каждую запись (infra/valkey/valkey.conf).
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import secrets
|
||||
import time
|
||||
from contextlib import contextmanager
|
||||
|
||||
import valkey
|
||||
from valkey.backoff import NoBackoff
|
||||
from valkey.retry import Retry
|
||||
|
||||
from .errors import Unavailable
|
||||
from .timeutil import from_micros
|
||||
|
||||
|
||||
@contextmanager
|
||||
def _valkey_errors():
|
||||
# Любая ошибка Valkey (нет соединения, таймаут, загрузка AOF после рестарта, нехватка памяти)
|
||||
# превращается в 503. Запрос не продолжается как анонимный и не считается доверенным.
|
||||
try:
|
||||
yield
|
||||
except valkey.exceptions.ValkeyError as error:
|
||||
raise Unavailable('valkey') from error
|
||||
|
||||
|
||||
class SessionStore:
|
||||
def __init__(self, url, ttl_seconds):
|
||||
self.ttl_seconds = ttl_seconds
|
||||
self._pool = valkey.BlockingConnectionPool.from_url(
|
||||
url,
|
||||
max_connections=20, # не больше 20 соединений на процесс
|
||||
timeout=1, # ждать свободное соединение не дольше 1 с
|
||||
socket_connect_timeout=1, # подключение и ответ — не дольше 1 с
|
||||
socket_timeout=1,
|
||||
retry=Retry(NoBackoff(), 1), # один повтор: переподключиться после рестарта Valkey
|
||||
decode_responses=True,
|
||||
)
|
||||
self._client = valkey.Valkey(connection_pool=self._pool)
|
||||
|
||||
@staticmethod
|
||||
def _key(token):
|
||||
# В Valkey хранится только хеш токена: копия базы не даёт готовых токенов.
|
||||
return 'session:' + hashlib.sha256(token.encode('ascii')).hexdigest()
|
||||
|
||||
def create(self, user_id):
|
||||
"""Новая сессия: (токен, срок действия как datetime)."""
|
||||
token = secrets.token_urlsafe(32) # 32 случайных байта = 256 бит
|
||||
expires_ms = int(time.time() * 1000) + self.ttl_seconds * 1000
|
||||
value = json.dumps({'user_id': user_id, 'expires_at_ms': expires_ms})
|
||||
with _valkey_errors():
|
||||
self._client.set(self._key(token), value, pxat=expires_ms)
|
||||
return token, from_micros(expires_ms * 1000)
|
||||
|
||||
def user_id(self, token):
|
||||
"""user_id владельца действующей сессии или None (неизвестна, отозвана, истекла)."""
|
||||
with _valkey_errors():
|
||||
raw = self._client.get(self._key(token))
|
||||
if raw is None:
|
||||
return None
|
||||
session = json.loads(raw)
|
||||
# Valkey удаляет ключ сам; проверка здесь — страховка на случай расхождения часов.
|
||||
if session['expires_at_ms'] <= time.time() * 1000:
|
||||
return None
|
||||
return session['user_id']
|
||||
|
||||
def revoke(self, token):
|
||||
"""Удаляет сессию; True, если она была."""
|
||||
with _valkey_errors():
|
||||
return self._client.delete(self._key(token)) == 1
|
||||
|
||||
def ping(self):
|
||||
with _valkey_errors():
|
||||
self._client.ping()
|
||||
|
||||
def close(self):
|
||||
self._pool.disconnect()
|
||||
@@ -0,0 +1,18 @@
|
||||
"""Время в формате контракта: RFC 3339, UTC, микросекунды, суффикс Z."""
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
|
||||
MICROSECOND = timedelta(microseconds=1)
|
||||
|
||||
|
||||
def format_time(value):
|
||||
return value.astimezone(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
|
||||
|
||||
|
||||
def to_micros(value):
|
||||
"""Целое число микросекунд с 1970 года: так время хранится в cursor без потери точности."""
|
||||
return (value - EPOCH) // MICROSECOND
|
||||
|
||||
|
||||
def from_micros(micros):
|
||||
return EPOCH + timedelta(microseconds=micros)
|
||||
@@ -0,0 +1,219 @@
|
||||
"""Разбор и проверка входных данных по contracts/openapi.json и contracts/README.md."""
|
||||
import base64
|
||||
import binascii
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
|
||||
from .errors import bad_request
|
||||
|
||||
USERNAME = re.compile(r'[a-z0-9_]{3,32}')
|
||||
UUID = re.compile(r'[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}')
|
||||
LIMIT = re.compile(r'[0-9]{1,3}')
|
||||
# Idempotency-Key из контракта: ASCII-символы [A-Za-z0-9._:-], от 1 до 128.
|
||||
IDEMPOTENCY_KEY = re.compile(r'[A-Za-z0-9._:-]{1,128}')
|
||||
# token68 из RFC 7235 с разумным ограничением длины.
|
||||
BEARER_TOKEN = re.compile(r'[A-Za-z0-9\-._~+/]{1,512}=*')
|
||||
|
||||
DEFAULT_LIMIT = 50
|
||||
MAX_LIMIT = 100
|
||||
MAX_NAME = 100
|
||||
MAX_MEMBERS = 100
|
||||
MAX_TEXT = 4000
|
||||
MIN_PASSWORD = 12
|
||||
MAX_PASSWORD = 128
|
||||
|
||||
|
||||
def parse_uuid(value):
|
||||
"""UUID в каноническом виде (нижний регистр) или None."""
|
||||
if isinstance(value, str) and UUID.fullmatch(value):
|
||||
return value.lower()
|
||||
return None
|
||||
|
||||
|
||||
def _load_object(raw, fields):
|
||||
"""JSON-объект ровно с полями fields: лишние и отсутствующие поля — ошибка."""
|
||||
try:
|
||||
data = json.loads(raw.decode('utf-8'))
|
||||
except (ValueError, RecursionError):
|
||||
raise bad_request('Тело запроса должно быть корректным JSON в UTF-8')
|
||||
if not isinstance(data, dict):
|
||||
raise bad_request('Тело запроса должно быть JSON-объектом')
|
||||
for field in fields:
|
||||
if field not in data:
|
||||
raise bad_request('Отсутствует обязательное поле ' + field)
|
||||
if len(data) != len(fields):
|
||||
raise bad_request('В запросе есть лишние поля')
|
||||
return data
|
||||
|
||||
|
||||
def _string(data, field, max_length, min_length=1):
|
||||
"""Строка из min_length..max_length code points, не только из пробельных символов."""
|
||||
value = data[field]
|
||||
if not isinstance(value, str):
|
||||
raise bad_request('Поле %s должно быть строкой' % field)
|
||||
if not value.strip():
|
||||
raise bad_request('Поле %s не должно быть пустым' % field)
|
||||
if not min_length <= len(value) <= max_length:
|
||||
raise bad_request('Поле %s: от %d до %d символов' % (field, min_length, max_length))
|
||||
# NUL нельзя сохранить в тексте PostgreSQL; одиночный суррогат (\ud800) нельзя вернуть в UTF-8.
|
||||
if '\x00' in value:
|
||||
raise bad_request('Поле %s содержит недопустимые символы' % field)
|
||||
try:
|
||||
value.encode('utf-8')
|
||||
except UnicodeEncodeError:
|
||||
raise bad_request('Поле %s содержит недопустимые символы' % field)
|
||||
return value
|
||||
|
||||
|
||||
def parse_create_user(raw):
|
||||
data = _load_object(raw, ('username', 'display_name', 'password'))
|
||||
username = data['username']
|
||||
if not isinstance(username, str) or not USERNAME.fullmatch(username):
|
||||
raise bad_request('username: 3-32 символа из набора a-z, 0-9 и _')
|
||||
display_name = _string(data, 'display_name', MAX_NAME)
|
||||
password = _string(data, 'password', MAX_PASSWORD, MIN_PASSWORD)
|
||||
return username, display_name, password
|
||||
|
||||
|
||||
def parse_create_chat(raw):
|
||||
data = _load_object(raw, ('title', 'member_ids'))
|
||||
title = _string(data, 'title', MAX_NAME)
|
||||
raw_ids = data['member_ids']
|
||||
if not isinstance(raw_ids, list) or not 1 <= len(raw_ids) <= MAX_MEMBERS:
|
||||
raise bad_request('member_ids: список из 1-%d UUID' % MAX_MEMBERS)
|
||||
member_ids = [parse_uuid(item) for item in raw_ids]
|
||||
if None in member_ids:
|
||||
raise bad_request('member_ids должен содержать только UUID')
|
||||
if len(set(member_ids)) != len(member_ids):
|
||||
raise bad_request('member_ids не должен содержать повторов')
|
||||
return title, member_ids
|
||||
|
||||
|
||||
def parse_create_message(raw):
|
||||
try:
|
||||
data = json.loads(raw.decode('utf-8'))
|
||||
except (ValueError, RecursionError):
|
||||
raise bad_request('Тело запроса должно быть корректным JSON в UTF-8')
|
||||
if not isinstance(data, dict) or 'text' not in data or set(data) - {'text', 'attachment_ids'}:
|
||||
raise bad_request('Нужен text и необязательный attachment_ids')
|
||||
text = data['text']
|
||||
if not isinstance(text, str) or len(text) > MAX_TEXT or '\x00' in text:
|
||||
raise bad_request('text: строка до 4000 символов')
|
||||
try:
|
||||
text.encode('utf-8')
|
||||
except UnicodeEncodeError:
|
||||
raise bad_request('Недопустимые символы text')
|
||||
ids = data.get('attachment_ids', [])
|
||||
if not isinstance(ids, list) or len(ids) > 10:
|
||||
raise bad_request('attachment_ids: список до 10 UUID')
|
||||
ids = [parse_uuid(value) for value in ids]
|
||||
if None in ids or len(set(ids)) != len(ids):
|
||||
raise bad_request('attachment_ids: уникальные UUID')
|
||||
if not text.strip() and not ids:
|
||||
raise bad_request('Нужен непустой текст или вложение')
|
||||
return text, ids
|
||||
|
||||
|
||||
def parse_idempotency_key(header):
|
||||
"""Значение заголовка Idempotency-Key; без него или в неверном формате — 400."""
|
||||
if header is None:
|
||||
raise bad_request('Нужен заголовок Idempotency-Key')
|
||||
if not IDEMPOTENCY_KEY.fullmatch(header):
|
||||
raise bad_request('Idempotency-Key: от 1 до 128 символов из набора A-Z, a-z, 0-9 и ._:-')
|
||||
return header
|
||||
|
||||
|
||||
def request_fingerprint(text, attachment_ids=()):
|
||||
"""sha256 разобранного тела: порядок ключей и пробелы в JSON не влияют на сравнение повторов."""
|
||||
canonical = json.dumps({'text': text, 'attachment_ids': list(attachment_ids)},
|
||||
ensure_ascii=False, sort_keys=True, separators=(',', ':'))
|
||||
return hashlib.sha256(canonical.encode('utf-8')).hexdigest()
|
||||
|
||||
|
||||
def _credentials(header, scheme):
|
||||
"""Значение после схемы авторизации (схема без учёта регистра) или None."""
|
||||
if not header:
|
||||
return None
|
||||
name, _, value = header.strip().partition(' ')
|
||||
if name.lower() != scheme:
|
||||
return None
|
||||
return value.strip()
|
||||
|
||||
|
||||
def parse_basic(header):
|
||||
"""(username, password) из Authorization: Basic base64(username:password) или None.
|
||||
|
||||
Пароль в UTF-8 и может содержать двоеточие: делим по первому. Всё, что не может быть
|
||||
правильной парой логин/пароль, возвращает None — дальше это обычный ответ 401.
|
||||
"""
|
||||
value = _credentials(header, 'basic')
|
||||
if not value:
|
||||
return None
|
||||
try:
|
||||
decoded = base64.b64decode(value, validate=True).decode('utf-8')
|
||||
except (binascii.Error, ValueError):
|
||||
return None
|
||||
username, separator, password = decoded.partition(':')
|
||||
if not separator or not USERNAME.fullmatch(username):
|
||||
return None
|
||||
if not MIN_PASSWORD <= len(password) <= MAX_PASSWORD:
|
||||
return None
|
||||
return username, password
|
||||
|
||||
|
||||
def parse_bearer(header):
|
||||
"""Токен из Authorization: Bearer <token> или None."""
|
||||
value = _credentials(header, 'bearer')
|
||||
if not value or not BEARER_TOKEN.fullmatch(value):
|
||||
return None
|
||||
return value
|
||||
|
||||
|
||||
def _single(query, name):
|
||||
"""Значение параметра запроса; None, если параметра нет."""
|
||||
values = query.get(name)
|
||||
if values is None:
|
||||
return None
|
||||
if len(values) != 1:
|
||||
raise bad_request('Параметр %s указан несколько раз' % name)
|
||||
return values[0]
|
||||
|
||||
|
||||
def parse_limit(query):
|
||||
value = _single(query, 'limit')
|
||||
if value is None:
|
||||
return DEFAULT_LIMIT
|
||||
if not LIMIT.fullmatch(value) or not 1 <= int(value) <= MAX_LIMIT:
|
||||
raise bad_request('limit должен быть целым числом от 1 до %d' % MAX_LIMIT)
|
||||
return int(value)
|
||||
|
||||
|
||||
def encode_cursor(scope, key):
|
||||
"""Непрозрачный для клиента cursor: область действия и ключ (created_at, id) последней записи."""
|
||||
if key is None:
|
||||
return None
|
||||
raw = '%s|%d|%s' % (scope, key[0], key[1])
|
||||
return base64.urlsafe_b64encode(raw.encode('ascii')).decode('ascii').rstrip('=')
|
||||
|
||||
|
||||
def parse_cursor(query, scope):
|
||||
"""Ключ (created_at в мкс, id), после которого продолжать; None без cursor.
|
||||
|
||||
scope привязывает cursor к ресурсу: cursor от другого чата — 400.
|
||||
"""
|
||||
value = _single(query, 'cursor')
|
||||
if value is None:
|
||||
return None
|
||||
try:
|
||||
padded = value + '=' * (-len(value) % 4)
|
||||
raw = base64.b64decode(padded, altchars=b'-_', validate=True).decode('ascii')
|
||||
cursor_scope, micros, entry_id = raw.split('|')
|
||||
if cursor_scope != scope or not micros.isdigit() or parse_uuid(entry_id) != entry_id:
|
||||
raise ValueError
|
||||
# Ограничение длины защищает от чисел, которые не влезут в дату PostgreSQL.
|
||||
if len(micros) > 17:
|
||||
raise ValueError
|
||||
return int(micros), entry_id
|
||||
except ValueError:
|
||||
raise bad_request('Некорректный cursor')
|
||||
Reference in New Issue
Block a user