forked from mtusi2026/mtusi2026lab7
Перенесена реализация 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.
471 lines
24 KiB
Python
471 lines
24 KiB
Python
"""Работа с 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
|