Files
mtusi2026lab7/src/store.py
T
zemiles 9cc80d2529 ЛР 7 — БПИ2303 — Лазарев — на 3
Перенесена реализация lab6; бизнес-API без изменений, транспорт — HTTPS.

- Внешний HTTPS (public-ca) на 127.0.0.1:8443; HSTS, TLS >= 1.2.
- Обязательное mTLS LB -> каждая API-реплика: API проверяет цепочку
  internal-ca и SAN клиента (allowlist: lb); health только на 127.0.0.1.
- TLS с проверкой сервера ко всем зависимостям: PostgreSQL verify-full
  (pg_hba только hostssl), HTTPS S3, AMQPS, OTLP/HTTPS с client cert,
  mTLS Collector -> Prometheus/Loki/Tempo, Grafana -> datasources, scrape.
- OpenBao 2.7.2 не в dev-mode: Raft на volume, init/unseal оператором,
  auth/cert с ролью и policy на сервис, TTL 15 мин + renew/re-login.
- Отдельные роли PostgreSQL с грантами по таблицам; разные ключи S3 и
  пользователи брокера выдаются из OpenBao.
- Argon2id (m=19 MiB, t=2, p=1, замер на стенде) и rehash при входе.
- Случайный X-Instance-Id; hardening контейнеров (non-root, cap_drop ALL,
  no-new-privileges, read-only, лимиты); TCP_NODELAY на сокете API.
- Модель угроз, trust matrix, отрицательные тесты TLS/mTLS, API, OpenBao,
  hardening; evidence, в т.ч. прогон из чистого clone.
2026-11-18 23:59:35 +03:00

471 lines
24 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Работа с PostgreSQL: пользователи, чаты, сообщения, сессии, метаданные вложений.
Lab5: вложение создаётся как pending (скрыто), после записи оригинала в staging одной
транзакцией становится queued вместе с заданием и записью outbox (src/jobs.py).
Источник истины — база данных. В памяти процесса состояния нет, поэтому
перезапуск API (и самой БД с сохранённым volume) не теряет данные.
Lab6: каждая публичная операция — CLIENT span «db <операция>» и гистограмма
db.client.operation.duration{db.operation.name}; ожидание соединения пула — отдельная
гистограмма db.client.connection.wait_time и атрибут span. По ним медленная/заблокированная БД
отличается от медленного кода обработчика (spans db длинные vs короткие).
"""
import contextlib
import datetime as dt
import logging
import time
import uuid
from pathlib import Path
import psycopg
from psycopg.rows import dict_row
import jobs
import telemetry
from psycopg_pool import ConnectionPool
from telemetry import db_operation
log = logging.getLogger("messenger.store")
EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc)
MIGRATIONS_LOCK_ID = 727001 # произвольный номер advisory-блокировки для миграций
class Conflict(Exception):
pass
class UnknownMember(Exception):
pass
class AttachmentNotFound(Exception):
"""Вложение неизвестно, не принято (pending) или принадлежит другому чату -> 404."""
class AttachmentFailed(Exception):
"""Вложение в состоянии failed: прикреплять нельзя -> 409."""
def format_ts(value):
"""datetime -> RFC 3339 UTC с микросекундами и суффиксом Z."""
return value.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def to_micros(value):
delta = value - EPOCH
return (delta.days * 86400 + delta.seconds) * 1_000_000 + delta.microseconds
def from_micros(micros):
return EPOCH + dt.timedelta(microseconds=micros)
def _user(row):
# Пароль/hash и сессионные данные никогда не входят в User.
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": format_ts(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_ts(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"],
"created_at": format_ts(row["created_at"]),
"attachment_ids": [str(a) for a in (row["attachment_ids"] or [])],
}
def _attachment(row):
# Наружу не отдаются object_key, bucket и внутренние адреса.
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"owner_id": str(row["owner_id"]),
"filename": row["filename"],
"content_type": row["content_type"],
"size_bytes": row["size_bytes"],
"sha256": row["sha256"],
"status": row["status"],
# Варианты показываются только у ready (их наличие = готовность уровня).
"variants": list(row["variants"] or []) if row["status"] == "ready" else [],
"error_code": row["error_code"] if row["status"] == "failed" else None,
"created_at": format_ts(row["created_at"]),
"updated_at": format_ts(row["updated_at"]),
}
ATTACHMENT_COLUMNS = """a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256,
a.status, a.error_code, a.object_key, a.created_at, a.updated_at,
(SELECT json_agg(json_build_object('name', v.name, 'content_type', v.content_type,
'size_bytes', v.size_bytes, 'width', v.width, 'height', v.height, 'sha256', v.sha256)
ORDER BY array_position(ARRAY['thumbnail','crop','optimized'], v.name))
FROM attachment_variants v
WHERE v.attachment_id = a.id AND v.pipeline_version = a.pipeline_version) AS variants"""
MESSAGE_COLUMNS = """m.id, m.chat_id, m.sender_id, m.text, m.created_at,
(SELECT array_agg(ma.attachment_id ORDER BY ma.position) FROM message_attachments ma
WHERE ma.message_id = m.id) AS attachment_ids"""
CHAT_COLUMNS = """c.id, c.title, c.created_at,
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids"""
class InstrumentedPool(ConnectionPool):
"""ConnectionPool, который измеряет ожидание соединения (насыщение пула видно в метриках)."""
@contextlib.contextmanager
def connection(self, timeout=None):
started = time.perf_counter()
outcome = {}
try:
conn = self.getconn(timeout=timeout)
except Exception as exc:
outcome["error.type"] = type(exc).__name__
raise
finally:
waited = time.perf_counter() - started
telemetry.db_wait.record(waited, dict({"db.client.connection.pool.name": "api",
"db.system.name": telemetry.DB_SYSTEM}, **outcome))
span = telemetry.trace.get_current_span()
if span.is_recording():
span.set_attribute("db.client.connection.wait_time_ms", round(waited * 1000, 3))
try:
with conn:
yield conn
finally:
self.putconn(conn)
class Store:
def __init__(self, conninfo, pool_size=10, pool_timeout=3):
# check: перед выдачей соединение проверяется. После перезапуска PostgreSQL
# «мёртвые» соединения отбрасываются, и запрос не получает ложный 503.
self.pool = InstrumentedPool(
conninfo, min_size=1, max_size=pool_size, timeout=pool_timeout,
kwargs={"row_factory": dict_row}, open=False,
check=ConnectionPool.check_connection)
# --- запуск ---
def open(self, wait_seconds=60):
"""Ждём готовности БД (она может стартовать дольше API) и открываем пул."""
self.pool.open()
deadline = time.monotonic() + wait_seconds
while True:
try:
with self.pool.connection() as conn:
conn.execute("SELECT 1")
return
except Exception as exc:
if time.monotonic() > deadline:
raise
log.info("database is not ready yet (%s), retrying", type(exc).__name__)
time.sleep(1)
def close(self):
self.pool.close()
def migrate(self, directory):
"""Применяет *.sql по порядку имён; каждая миграция — одна транзакция, один раз."""
files = sorted(Path(directory).glob("*.sql"))
with self.pool.connection() as conn:
# Advisory-блокировка (сессионная): параллельный повторный запуск job не устроит гонку.
conn.autocommit = True
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATIONS_LOCK_ID,))
try:
conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())""")
done = {r["version"] for r in conn.execute("SELECT version FROM schema_migrations")}
for path in files:
if path.name in done:
continue
# Миграция и её отметка — одна транзакция: либо целиком, либо никак.
with conn.transaction():
conn.execute(path.read_text(encoding="utf-8"))
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
log.info("migration applied: %s", path.name)
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATIONS_LOCK_ID,))
conn.autocommit = False
def pending_migrations(self, directory):
"""Миграции из каталога образа, ещё не применённые к БД (API их НЕ применяет)."""
files = sorted(p.name for p in Path(directory).glob("*.sql"))
with self.pool.connection() as conn:
exists = conn.execute("SELECT to_regclass('schema_migrations') IS NOT NULL AS ok").fetchone()["ok"]
done = {r["version"] for r in conn.execute("SELECT version FROM schema_migrations")} if exists else set()
return [f for f in files if f not in done]
@db_operation("ping")
def ping(self):
with self.pool.connection() as conn:
conn.execute("SELECT 1")
# --- пользователи ---
@db_operation("create_user")
def create_user(self, username, display_name, password_hash):
try:
with self.pool.connection() as conn:
row = conn.execute(
"""INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, clock_timestamp())
RETURNING id, username, display_name, created_at""",
(uuid.uuid4(), username, display_name, password_hash)).fetchone()
except psycopg.errors.UniqueViolation:
# Уникальность гарантирует сама БД — гонка двух регистраций безопасна.
raise Conflict()
return _user(row)
@db_operation("get_credentials")
def get_credentials(self, username):
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,)).fetchone()
if row is None:
return None, None
return _user(row), row["password_hash"]
@db_operation("rehash_password")
def update_password_hash(self, user_id, old_hash, new_hash):
"""Lab7 rehash: заменяем только тот хеш, который проверяли (гонка двух входов безопасна)."""
with self.pool.connection() as conn:
conn.execute("UPDATE users SET password_hash = %s WHERE id = %s AND password_hash = %s",
(new_hash, user_id, old_hash))
# --- сессии ---
@db_operation("create_session")
def create_session(self, user_id, token_hash, ttl_seconds):
with self.pool.connection() as conn:
row = conn.execute(
"""INSERT INTO sessions (token_hash, user_id, created_at, expires_at)
VALUES (%s, %s, now(), now() + make_interval(secs => %s))
RETURNING expires_at""",
(token_hash, user_id, ttl_seconds)).fetchone()
return format_ts(row["expires_at"])
@db_operation("get_session_user")
def get_session_user(self, token_hash):
"""Пользователь действующей сессии или None (неизвестна/истекла/отозвана)."""
with self.pool.connection() as conn:
row = conn.execute(
"""SELECT u.id, u.username, u.display_name, u.created_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = %s AND s.revoked_at IS NULL AND s.expires_at > now()""",
(token_hash,)).fetchone()
return _user(row) if row else None
@db_operation("revoke_session")
def revoke_session(self, token_hash):
with self.pool.connection() as conn:
conn.execute(
"UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
(token_hash,))
# --- чаты ---
@db_operation("create_chat")
def create_chat(self, title, member_ids):
"""Чат и его участники создаются в одной транзакции (атомарно)."""
chat_id = uuid.uuid4()
with self.pool.connection() as conn:
found = conn.execute(
"SELECT count(*) AS n FROM users WHERE id = ANY(%s::uuid[])", (member_ids,)).fetchone()["n"]
if found != len(member_ids):
raise UnknownMember()
conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, clock_timestamp())",
(chat_id, title))
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
[(chat_id, m, i) for i, m in enumerate(member_ids)])
row = conn.execute("SELECT " + CHAT_COLUMNS + " FROM chats c WHERE c.id = %s", (chat_id,)).fetchone()
return _chat(row)
@db_operation("get_chat_for")
def get_chat_for(self, user_id, chat_id):
"""Чат, если пользователь — участник; иначе None (чужой и несуществующий неразличимы)."""
with self.pool.connection() as conn:
row = conn.execute(
"SELECT " + CHAT_COLUMNS + """ 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)""",
(chat_id, user_id)).fetchone()
return _chat(row) if row else None
@db_operation("list_chats")
def list_chats(self, user_id, after, limit):
params = [user_id]
where = ""
if after:
where = "AND (c.created_at, c.id) > (%s, %s::uuid)"
params += [from_micros(after[0]), after[1]]
params.append(limit + 1) # +1 запись: узнаём, есть ли следующая страница
with self.pool.connection() as conn:
rows = conn.execute(
"SELECT " + CHAT_COLUMNS + """ FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
WHERE true """ + where + " ORDER BY c.created_at, c.id LIMIT %s", params).fetchall()
return self._page(rows, limit, _chat)
# --- сообщения ---
@db_operation("add_message")
def add_message(self, user_id, chat_id, text, attachment_ids, idem_key, request_hash, idem_ttl_seconds):
"""Идемпотентная отправка. Возвращает (message, replayed) или None, если чата нет/он чужой.
Всё в ОДНОЙ транзакции: проверка доступа, поиск ключа, вставка сообщения и запись
ключа. Либо фиксируется и сообщение, и ключ, либо ничего (транзиентная ошибка
не запоминается как результат — клиент повторит с тем же ключом).
Конкурентные запросы с одним ключом через разные реплики сериализуются
блокировкой строки чата (FOR UPDATE), второй после COMMIT первого видит ключ.
PK таблицы ключей — страховка: даже без блокировки дубль не зафиксируется.
Lab4: в той же транзакции проверяется, что все attachment_ids — ready-вложения
ЭТОГО чата (FOR SHARE: строка не исчезнет до COMMIT), и пишутся ссылки.
"""
with self.pool.connection() as conn:
# FOR UPDATE по строке чата: вставки в один чат идут по очереди, поэтому
# created_at растёт в порядке фиксации и keyset-курсор не пропускает записи.
allowed = conn.execute(
"""SELECT 1 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)
FOR UPDATE OF c""", (chat_id, user_id)).fetchone()
if allowed is None:
return None
existing = conn.execute(
"""SELECT k.request_hash, k.expires_at > now() AS alive, """ + MESSAGE_COLUMNS + """
FROM idempotency_keys k JOIN messages m ON m.id = k.message_id
WHERE k.user_id = %s AND k.chat_id = %s AND k.idem_key = %s""",
(user_id, chat_id, idem_key)).fetchone()
if existing is not None:
if existing["alive"]:
if bytes(existing["request_hash"]) != request_hash:
raise Conflict()
return _message(existing), True
# Ключ старше TTL (24 ч) — освобождаем его и обрабатываем как новый.
conn.execute(
"DELETE FROM idempotency_keys WHERE user_id = %s AND chat_id = %s AND idem_key = %s",
(user_id, chat_id, idem_key))
if attachment_ids:
# Lab5: queued/processing/ready можно прикреплять; failed — 409;
# pending (upload ещё не принят) — как неизвестное.
found = conn.execute(
"""SELECT id, status FROM attachments
WHERE id = ANY(%s::uuid[]) AND chat_id = %s AND status <> 'pending'
FOR SHARE""", (attachment_ids, chat_id)).fetchall()
if len(found) != len(attachment_ids):
# Чужой чат, неизвестный или непринятый id — одинаково 404.
raise AttachmentNotFound()
if any(r["status"] == "failed" for r in found):
raise AttachmentFailed()
row = conn.execute(
"""INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (%s, %s, %s, %s, clock_timestamp())
RETURNING id, chat_id, sender_id, text, created_at""",
(uuid.uuid4(), chat_id, user_id, text)).fetchone()
if attachment_ids:
with conn.cursor() as cur:
cur.executemany(
"""INSERT INTO message_attachments (message_id, attachment_id, position)
VALUES (%s, %s, %s)""",
[(row["id"], a, i) for i, a in enumerate(attachment_ids)])
row = dict(row, attachment_ids=list(attachment_ids))
conn.execute(
"""INSERT INTO idempotency_keys (user_id, chat_id, idem_key, request_hash, message_id, expires_at)
VALUES (%s, %s, %s, %s, %s, now() + make_interval(secs => %s))""",
(user_id, chat_id, idem_key, request_hash, row["id"], idem_ttl_seconds))
return _message(row), False
@db_operation("list_messages")
def list_messages(self, chat_id, after, limit):
params = [chat_id]
where = ""
if after:
where = "AND (m.created_at, m.id) > (%s, %s::uuid)"
params += [from_micros(after[0]), after[1]]
params.append(limit + 1)
with self.pool.connection() as conn:
rows = conn.execute(
"SELECT " + MESSAGE_COLUMNS + " FROM messages m WHERE m.chat_id = %s "
+ where + " ORDER BY m.created_at, m.id LIMIT %s", params).fetchall()
return self._page(rows, limit, _message)
# --- вложения ---
@db_operation("create_pending_attachment")
def create_pending_attachment(self, att_id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, width, height, object_key, staging_key, pipeline_version):
"""Шаг 1: намерение фиксируется ДО PUT в staging (как в lab4). Строка pending
API не показывает; брошенную (крах до постановки в очередь) убирает janitor."""
with self.pool.connection() as conn:
conn.execute(
"""INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes,
sha256, width, height, object_key, staging_key, pipeline_version, status, created_at, updated_at)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'pending', now(), now())""",
(att_id, chat_id, owner_id, filename, content_type, size_bytes, sha256,
width, height, object_key, staging_key, pipeline_version))
@db_operation("enqueue_attachment")
def enqueue_attachment(self, att_id, pipeline_version, max_attempts, before_commit=None):
"""Шаг 3 (после PUT в staging): ОДНА транзакция pending -> queued + jobs + outbox.
После COMMIT работа принята: даже если API сразу упадёт, relay опубликует задание.
None — строку уже убрал janitor (ответ 503)."""
with self.pool.connection() as conn:
job_id = jobs.enqueue(conn, att_id, pipeline_version, max_attempts)
if job_id is None:
return None
if before_commit:
before_commit()
row = conn.execute("SELECT " + ATTACHMENT_COLUMNS + " FROM attachments a WHERE a.id = %s",
(att_id,)).fetchone()
return _attachment(row)
@db_operation("delete_pending_attachment")
def delete_pending_attachment(self, att_id):
"""Компенсация: убрать непринятое намерение (staging-объект удалён/не создан)."""
with self.pool.connection() as conn:
conn.execute("DELETE FROM attachments WHERE id = %s AND status = 'pending'", (att_id,))
@db_operation("get_attachment_for")
def get_attachment_for(self, user_id, att_id):
"""(attachment, object_key) для участника чата; иначе None. Pending не виден."""
with self.pool.connection() as conn:
row = conn.execute(
"SELECT " + ATTACHMENT_COLUMNS + """ FROM attachments a
WHERE a.id = %s AND a.status <> 'pending' AND EXISTS (
SELECT 1 FROM chat_members m WHERE m.chat_id = a.chat_id AND m.user_id = %s)""",
(att_id, user_id)).fetchone()
return (_attachment(row), row["object_key"]) if row else None
@db_operation("get_variant_key")
def get_variant_key(self, att_id, name):
"""object_key варианта текущей версии pipeline (или None)."""
with self.pool.connection() as conn:
row = conn.execute(
"""SELECT v.object_key FROM attachment_variants v JOIN attachments a ON a.id = v.attachment_id
WHERE v.attachment_id = %s AND v.name = %s AND v.pipeline_version = a.pipeline_version""",
(att_id, name)).fetchone()
return row["object_key"] if row else None
@staticmethod
def _page(rows, limit, convert):
has_more = len(rows) > limit
rows = rows[:limit]
last = (to_micros(rows[-1]["created_at"]), str(rows[-1]["id"])) if rows and has_more else None
return [convert(r) for r in rows], last