"""Работа с 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