ЛР 4 — БВТ2304 — Черников — на 4

This commit is contained in:
2026-11-05 13:41:57 +03:00
parent ec540a1a72
commit f878147188
61 changed files with 4622 additions and 21 deletions
+1
View File
@@ -0,0 +1 @@
"""In-memory мессенджер, лабораторная 1. Только стандартная библиотека Python."""
+94
View File
@@ -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())
+31
View File
@@ -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()
+55
View File
@@ -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()
+84
View File
@@ -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'),
)
+280
View File
@@ -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
+29
View File
@@ -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', 'Объект не найден')
+26
View File
@@ -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())
+29
View File
@@ -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())
+77
View File
@@ -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())
+40
View File
@@ -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']
+50
View File
@@ -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
+489
View File
@@ -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)
+81
View File
@@ -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()
+18
View File
@@ -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)
+219
View File
@@ -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')