forked from mtusi2026/mtusi2026lab6
Лабораторная работа 6
This commit is contained in:
+661
@@ -0,0 +1,661 @@
|
||||
"""Доступ к PostgreSQL. Все запросы параметризованы (%s), SQL не склеивается
|
||||
со значениями пользователя. Каждая публичная операция — одна транзакция
|
||||
(`with pool.connection()` делает COMMIT при успехе и ROLLBACK при исключении).
|
||||
"""
|
||||
from datetime import datetime
|
||||
from typing import List, Optional, Sequence, Tuple
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from psycopg import errors
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg.types.json import Jsonb
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
from .models import Attachment, Chat, Message, User, Variant
|
||||
|
||||
|
||||
class UsernameTaken(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class UnknownMember(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class NotChatMember(Exception):
|
||||
"""Чата нет или пользователь не участник -> 404."""
|
||||
|
||||
|
||||
class IdempotencyConflict(Exception):
|
||||
"""Тот же ключ уже использован с другим телом -> 409."""
|
||||
|
||||
|
||||
class IdempotencyRace(Exception):
|
||||
"""Строка ключа исчезла между шагами -> 503, клиент повторяет с тем же ключом."""
|
||||
|
||||
|
||||
class AttachmentNotFound(Exception):
|
||||
"""Вложение не существует, ещё не принято (pending) или принадлежит другому чату -> 404."""
|
||||
|
||||
|
||||
class AttachmentFailed(Exception):
|
||||
"""lab5: вложение в состоянии failed нельзя прикрепить к сообщению -> 409."""
|
||||
|
||||
|
||||
# Одна реплика за раз выполняет сборку мусора вложений (src/reconcile.py).
|
||||
ATTACHMENT_GC_LOCK_ID = 2026_0004
|
||||
|
||||
ATTACHMENT_COLUMNS = (
|
||||
"a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, "
|
||||
"a.sha256, a.state, a.error_code, a.pipeline_version, a.created_at, a.updated_at"
|
||||
)
|
||||
|
||||
# Внутреннее состояние -> публичный status. pending (приём ещё не завершён) наружу
|
||||
# не попадает: такие строки запросы API не выбирают.
|
||||
PUBLIC_STATES = ("queued", "processing", "ready", "failed")
|
||||
|
||||
# Подзапрос: attachment_ids сообщения в исходном порядке (position).
|
||||
MESSAGE_ATTACHMENT_IDS = (
|
||||
"COALESCE((SELECT array_agg(ma.attachment_id ORDER BY ma.position) "
|
||||
"FROM message_attachments ma WHERE ma.message_id = m.id), '{}'::uuid[]) AS attachment_ids"
|
||||
)
|
||||
|
||||
|
||||
def _attachment(row, variants=()) -> Attachment:
|
||||
state = row["state"]
|
||||
return Attachment(
|
||||
id=row["id"],
|
||||
chat_id=row["chat_id"],
|
||||
owner_id=row["owner_id"],
|
||||
filename=row["filename"],
|
||||
content_type=row["content_type"],
|
||||
size_bytes=row["size_bytes"],
|
||||
sha256=row["sha256"],
|
||||
status=state,
|
||||
# Варианты публикуются вместе со статусом ready (одна транзакция worker).
|
||||
variants=list(variants) if state == "ready" else [],
|
||||
error_code=row.get("error_code") if state == "failed" else None,
|
||||
created_at=row["created_at"],
|
||||
updated_at=row["updated_at"],
|
||||
)
|
||||
|
||||
|
||||
# Одна реплика за раз чистит истёкшие ключи идемпотентности.
|
||||
IDEMPOTENCY_CLEANUP_LOCK_ID = 2026_0003
|
||||
|
||||
|
||||
Position = Optional[Tuple[datetime, UUID]]
|
||||
|
||||
|
||||
def _user(row) -> User:
|
||||
return User(
|
||||
id=row["id"],
|
||||
username=row["username"],
|
||||
display_name=row["display_name"],
|
||||
created_at=row["created_at"],
|
||||
)
|
||||
|
||||
|
||||
class Storage:
|
||||
def __init__(self, pool: ConnectionPool) -> None:
|
||||
self.pool = pool
|
||||
|
||||
def ping(self) -> None:
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute("SELECT 1")
|
||||
|
||||
# users
|
||||
|
||||
def create_user(self, username: str, display_name: str, password_hash: str) -> User:
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
INSERT INTO users (id, username, display_name, password_hash)
|
||||
VALUES (%s, %s, %s, %s)
|
||||
RETURNING id, username, display_name, created_at
|
||||
""",
|
||||
(uuid4(), username, display_name, password_hash),
|
||||
).fetchone()
|
||||
except errors.UniqueViolation:
|
||||
# Гонку двух одинаковых регистраций решает UNIQUE(username) в БД,
|
||||
# а не проверка «SELECT, потом INSERT» в приложении.
|
||||
raise UsernameTaken()
|
||||
return _user(row)
|
||||
|
||||
def get_credentials(self, username: str) -> Optional[Tuple[User, str]]:
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
SELECT id, username, display_name, created_at, password_hash
|
||||
FROM users WHERE username = %s
|
||||
""",
|
||||
(username,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
return _user(row), row["password_hash"]
|
||||
|
||||
# sessions (источник истины)
|
||||
|
||||
def create_session(self, token_hash: bytes, user_id: UUID, ttl_seconds: int) -> datetime:
|
||||
with self.pool.connection() as conn:
|
||||
# Заодно убираем давно истёкшие сессии этого пользователя.
|
||||
conn.execute(
|
||||
"DELETE FROM sessions WHERE user_id = %s AND expires_at < now() - interval '1 day'",
|
||||
(user_id,),
|
||||
)
|
||||
row = conn.execute(
|
||||
"""
|
||||
INSERT INTO sessions (token_hash, user_id, expires_at)
|
||||
VALUES (%s, %s, clock_timestamp() + make_interval(secs => %s))
|
||||
RETURNING expires_at
|
||||
""",
|
||||
(token_hash, user_id, ttl_seconds),
|
||||
).fetchone()
|
||||
return row[0]
|
||||
|
||||
def find_session(self, token_hash: bytes) -> Optional[Tuple[User, datetime]]:
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
SELECT u.id, u.username, u.display_name, u.created_at, s.expires_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 > clock_timestamp()
|
||||
""",
|
||||
(token_hash,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
return _user(row), row["expires_at"]
|
||||
|
||||
def revoke_session(self, token_hash: bytes) -> bool:
|
||||
"""Отзыв и долг «инвалидировать кэш» фиксируются одним COMMIT."""
|
||||
with self.pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
row = conn.execute(
|
||||
"""
|
||||
UPDATE sessions SET revoked_at = clock_timestamp()
|
||||
WHERE token_hash = %s
|
||||
AND revoked_at IS NULL
|
||||
AND expires_at > clock_timestamp()
|
||||
RETURNING 1
|
||||
""",
|
||||
(token_hash,),
|
||||
).fetchone()
|
||||
if row is not None:
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO session_cache_invalidations (token_hash)
|
||||
VALUES (%s) ON CONFLICT (token_hash) DO NOTHING
|
||||
""",
|
||||
(token_hash,),
|
||||
)
|
||||
return row is not None
|
||||
|
||||
# долг инвалидации кэша
|
||||
|
||||
def has_pending_invalidations(self) -> bool:
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute(
|
||||
"SELECT EXISTS (SELECT 1 FROM session_cache_invalidations)"
|
||||
).fetchone()[0]
|
||||
|
||||
def pending_invalidations(self, limit: int = 500) -> List[Tuple[bytes, float]]:
|
||||
"""[(token_hash, возраст в секундах)] — самые старые первыми."""
|
||||
with self.pool.connection() as conn:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT token_hash, EXTRACT(EPOCH FROM clock_timestamp() - revoked_at)
|
||||
FROM session_cache_invalidations
|
||||
ORDER BY revoked_at LIMIT %s
|
||||
""",
|
||||
(limit,),
|
||||
).fetchall()
|
||||
return [(bytes(h), float(age)) for h, age in rows]
|
||||
|
||||
def delete_invalidations(self, token_hashes: Sequence[bytes]) -> None:
|
||||
if not token_hashes:
|
||||
return
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute(
|
||||
"DELETE FROM session_cache_invalidations WHERE token_hash = ANY(%s)",
|
||||
(list(token_hashes),),
|
||||
)
|
||||
|
||||
# chats
|
||||
|
||||
def _insert_members(self, conn, chat_id: UUID, member_ids: Sequence[UUID]) -> None:
|
||||
with conn.cursor() as cur:
|
||||
cur.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
|
||||
[(chat_id, member_id, pos) for pos, member_id in enumerate(member_ids)],
|
||||
)
|
||||
|
||||
def create_chat(self, title: str, member_ids: Sequence[UUID]) -> Chat:
|
||||
"""Чат и все участники создаются в одной транзакции.
|
||||
|
||||
Существование участников проверяет внешний ключ chat_members.user_id:
|
||||
если хоть один id неизвестен, INSERT падает, и откатывается вся
|
||||
транзакция, включая уже вставленную строку chats и других участников.
|
||||
"""
|
||||
chat_id = uuid4()
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
created_at = conn.execute(
|
||||
"INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at",
|
||||
(chat_id, title),
|
||||
).fetchone()[0]
|
||||
self._insert_members(conn, chat_id, member_ids)
|
||||
except errors.ForeignKeyViolation:
|
||||
raise UnknownMember()
|
||||
return Chat(id=chat_id, title=title, member_ids=list(member_ids), created_at=created_at)
|
||||
|
||||
def _members_for(self, conn, chat_ids: List[UUID]) -> dict:
|
||||
members = {chat_id: [] for chat_id in chat_ids}
|
||||
if not chat_ids:
|
||||
return members
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT chat_id, user_id FROM chat_members
|
||||
WHERE chat_id = ANY(%s) ORDER BY chat_id, position
|
||||
""",
|
||||
(chat_ids,),
|
||||
).fetchall()
|
||||
for chat_id, user_id in rows:
|
||||
members[chat_id].append(user_id)
|
||||
return members
|
||||
|
||||
def get_chat_for_member(self, chat_id: UUID, user_id: UUID) -> Optional[Chat]:
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chats c
|
||||
JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s
|
||||
WHERE c.id = %s
|
||||
""",
|
||||
(user_id, chat_id),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
members = self._members_for(conn, [row["id"]])
|
||||
return Chat(id=row["id"], title=row["title"], member_ids=members[row["id"]], created_at=row["created_at"])
|
||||
|
||||
def list_user_chats(self, user_id: UUID, limit: int, after: Position) -> Tuple[List[Chat], bool]:
|
||||
params: list = [user_id]
|
||||
keyset = ""
|
||||
if after is not None:
|
||||
keyset = "AND (c.created_at, c.id) > (%s, %s)"
|
||||
params.extend(after)
|
||||
params.append(limit + 1)
|
||||
with self.pool.connection() as conn:
|
||||
rows = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
SELECT c.id, c.title, c.created_at
|
||||
FROM chat_members m JOIN chats c ON c.id = m.chat_id
|
||||
WHERE m.user_id = %s {keyset}
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT %s
|
||||
""".format(keyset=keyset),
|
||||
params,
|
||||
).fetchall()
|
||||
has_more = len(rows) > limit
|
||||
rows = rows[:limit]
|
||||
members = self._members_for(conn, [r["id"] for r in rows])
|
||||
chats = [
|
||||
Chat(id=r["id"], title=r["title"], member_ids=members[r["id"]], created_at=r["created_at"])
|
||||
for r in rows
|
||||
]
|
||||
return chats, has_more
|
||||
|
||||
# messages
|
||||
|
||||
@staticmethod
|
||||
def _insert_message(conn, message_id: UUID, chat_id: UUID, sender_id: UUID, text: str) -> Optional[Message]:
|
||||
"""Проверка членства и вставка — один оператор, без окна гонки."""
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
INSERT INTO messages (id, chat_id, sender_id, text)
|
||||
SELECT %s, %s, %s, %s
|
||||
WHERE EXISTS (
|
||||
SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s
|
||||
)
|
||||
RETURNING id, chat_id, sender_id, text, created_at
|
||||
""",
|
||||
(message_id, chat_id, sender_id, text, chat_id, sender_id),
|
||||
).fetchone()
|
||||
return Message(**row) if row is not None else None
|
||||
|
||||
@staticmethod
|
||||
def _link_attachments(conn, message: Message, attachment_ids: Sequence[UUID]) -> None:
|
||||
"""Привязка вложений в той же транзакции, что и сообщение.
|
||||
|
||||
lab5: можно ссылаться на queued/processing/ready вложения ЭТОГО чата.
|
||||
Неизвестное/чужое/ещё не принятое (pending) -> AttachmentNotFound (404);
|
||||
failed -> AttachmentFailed (409). Любое исключение -> ROLLBACK сообщения и
|
||||
ключа идемпотентности. FOR KEY SHARE не даёт удалить строку до COMMIT;
|
||||
составной FK (attachment_id, chat_id) дублирует проверку чата в БД.
|
||||
"""
|
||||
if not attachment_ids:
|
||||
return
|
||||
ids = list(attachment_ids)
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT id, state FROM attachments
|
||||
WHERE id = ANY(%s) AND chat_id = %s AND state <> 'pending'
|
||||
FOR KEY SHARE
|
||||
""",
|
||||
(ids, message.chat_id),
|
||||
).fetchall()
|
||||
if len(rows) != len(ids):
|
||||
raise AttachmentNotFound()
|
||||
if any(state == "failed" for _id, state in rows):
|
||||
raise AttachmentFailed()
|
||||
with conn.cursor() as cur:
|
||||
cur.executemany(
|
||||
"""
|
||||
INSERT INTO message_attachments (message_id, attachment_id, chat_id, position)
|
||||
VALUES (%s, %s, %s, %s)
|
||||
""",
|
||||
[(message.id, aid, message.chat_id, pos) for pos, aid in enumerate(ids)],
|
||||
)
|
||||
message.attachment_ids = ids
|
||||
|
||||
def create_message(
|
||||
self,
|
||||
chat_id: UUID,
|
||||
sender_id: UUID,
|
||||
text: str,
|
||||
idem_key: str,
|
||||
request_hash: bytes,
|
||||
idem_ttl_seconds: int,
|
||||
attachment_ids: Sequence[UUID] = (),
|
||||
) -> Tuple[Message, bool]:
|
||||
"""Идемпотентная отправка. Возвращает (сообщение, replayed).
|
||||
|
||||
Всё — одна транзакция READ COMMITTED (см. migrations/003):
|
||||
1. INSERT строки ключа. Если такой ключ уже есть и он не истёк,
|
||||
ON CONFLICT ... WHERE ничего не меняет и RETURNING пуст. Если
|
||||
конкурентная транзакция с тем же ключом ещё не завершилась, INSERT
|
||||
ЖДЁТ её COMMIT/ROLLBACK на уникальном индексе — поэтому одновременные
|
||||
повторы через разные реплики создают ровно одно сообщение.
|
||||
2a. Ключ наш -> INSERT сообщения (с проверкой членства). Не участник ->
|
||||
исключение -> ROLLBACK: ключ не «сгорает» на 404.
|
||||
2b. Ключ чужой (уже подтверждён) -> снова проверяем доступ, сравниваем
|
||||
hash тела: совпал -> то же сообщение; нет -> 409.
|
||||
Ошибка/обрыв на любом шаге откатывает и ключ, и сообщение.
|
||||
"""
|
||||
new_id = uuid4()
|
||||
with self.pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
owned = conn.execute(
|
||||
"""
|
||||
INSERT INTO idempotency_keys
|
||||
(user_id, method, chat_id, idem_key, request_hash, message_id, expires_at)
|
||||
VALUES (%s, 'POST', %s, %s, %s, %s,
|
||||
clock_timestamp() + make_interval(secs => %s))
|
||||
ON CONFLICT (user_id, method, chat_id, idem_key) DO UPDATE
|
||||
SET request_hash = EXCLUDED.request_hash,
|
||||
message_id = EXCLUDED.message_id,
|
||||
created_at = clock_timestamp(),
|
||||
expires_at = EXCLUDED.expires_at
|
||||
-- истёкший (ещё не удалённый очисткой) ключ можно занять заново
|
||||
WHERE idempotency_keys.expires_at <= clock_timestamp()
|
||||
RETURNING message_id
|
||||
""",
|
||||
(sender_id, chat_id, idem_key, request_hash, new_id, idem_ttl_seconds),
|
||||
).fetchone()
|
||||
if owned is not None:
|
||||
message = self._insert_message(conn, new_id, chat_id, sender_id, text)
|
||||
if message is None:
|
||||
raise NotChatMember() # -> ROLLBACK вместе со строкой ключа
|
||||
# lab4: чужое/неготовое вложение -> исключение -> ROLLBACK всего.
|
||||
self._link_attachments(conn, message, attachment_ids)
|
||||
return message, False
|
||||
|
||||
# Ключ уже подтверждён другой (возможно, конкурентной) транзакцией.
|
||||
member = conn.execute(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(chat_id, sender_id),
|
||||
).fetchone()
|
||||
if member is None:
|
||||
raise NotChatMember()
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at,
|
||||
{attachments}
|
||||
FROM idempotency_keys k
|
||||
JOIN messages m ON m.id = k.message_id
|
||||
WHERE k.user_id = %s AND k.method = 'POST'
|
||||
AND k.chat_id = %s AND k.idem_key = %s
|
||||
""".format(attachments=MESSAGE_ATTACHMENT_IDS),
|
||||
(sender_id, chat_id, idem_key),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
# Теоретически: строка удалена между шагами (очистка/каскад).
|
||||
# Отдаём 503-подобную транзиентную ошибку, клиент повторит с тем же ключом.
|
||||
raise IdempotencyRace()
|
||||
if bytes(row.pop("request_hash")) != request_hash:
|
||||
raise IdempotencyConflict()
|
||||
return Message(**row), True
|
||||
|
||||
def delete_expired_idempotency_keys(self, batch: int = 1000) -> Optional[int]:
|
||||
"""Удаляет истёкшие ключи пачкой. None — очистку сейчас выполняет другая реплика."""
|
||||
with self.pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
got = conn.execute(
|
||||
"SELECT pg_try_advisory_xact_lock(%s)", (IDEMPOTENCY_CLEANUP_LOCK_ID,)
|
||||
).fetchone()[0]
|
||||
if not got:
|
||||
return None
|
||||
cur = conn.execute(
|
||||
"""
|
||||
DELETE FROM idempotency_keys
|
||||
WHERE ctid IN (
|
||||
SELECT ctid FROM idempotency_keys
|
||||
WHERE expires_at <= clock_timestamp()
|
||||
LIMIT %s
|
||||
)
|
||||
""",
|
||||
(batch,),
|
||||
)
|
||||
return cur.rowcount
|
||||
|
||||
def list_messages(
|
||||
self, chat_id: UUID, user_id: UUID, limit: int, after: Position
|
||||
) -> Optional[Tuple[List[Message], bool]]:
|
||||
params: list = [chat_id]
|
||||
keyset = ""
|
||||
if after is not None:
|
||||
keyset = "AND (created_at, id) > (%s, %s)"
|
||||
params.extend(after)
|
||||
params.append(limit + 1)
|
||||
with self.pool.connection() as conn:
|
||||
member = conn.execute(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(chat_id, user_id),
|
||||
).fetchone()
|
||||
if member is None:
|
||||
return None
|
||||
# Keyset-пагинация по индексу messages_chat_created_id_idx:
|
||||
# Index Scan сразу с позиции курсора, читается limit+1 строк.
|
||||
rows = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at,
|
||||
{attachments}
|
||||
FROM messages m
|
||||
WHERE m.chat_id = %s {keyset}
|
||||
ORDER BY m.created_at, m.id
|
||||
LIMIT %s
|
||||
""".format(keyset=keyset.replace("(created_at, id)", "(m.created_at, m.id)"),
|
||||
attachments=MESSAGE_ATTACHMENT_IDS),
|
||||
params,
|
||||
).fetchall()
|
||||
has_more = len(rows) > limit
|
||||
return [Message(**r) for r in rows[:limit]], has_more
|
||||
|
||||
# attachments (lab4)
|
||||
|
||||
def is_chat_member(self, chat_id: UUID, user_id: UUID) -> bool:
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute(
|
||||
"SELECT EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s)",
|
||||
(chat_id, user_id),
|
||||
).fetchone()[0]
|
||||
|
||||
def create_pending_attachment(
|
||||
self,
|
||||
attachment_id: UUID,
|
||||
chat_id: UUID,
|
||||
owner_id: UUID,
|
||||
filename: str,
|
||||
content_type: str,
|
||||
size_bytes: int,
|
||||
sha256: str,
|
||||
width: int,
|
||||
height: int,
|
||||
object_key: str,
|
||||
staging_key: Optional[str] = None,
|
||||
pipeline_version: int = 1,
|
||||
) -> bool:
|
||||
"""Шаг 1 из 3: намерение (state=pending) COMMIT до S3 PUT в staging.
|
||||
|
||||
У любого объекта, который API кладёт в бакет, уже есть строка с его ключом
|
||||
(staging_key): объект без строки может появиться только после удаления
|
||||
строки сборщиком и никогда не «потеряется» навсегда (src/reconcile.py).
|
||||
object_key — будущий конечный ключ оригинала, его запишет worker.
|
||||
Проверка членства и вставка — один оператор. False -> не участник.
|
||||
"""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
INSERT INTO attachments (id, chat_id, owner_id, filename, content_type,
|
||||
size_bytes, sha256, width, height, object_key,
|
||||
staging_key, pipeline_version, state)
|
||||
SELECT %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'pending'
|
||||
WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s)
|
||||
RETURNING 1
|
||||
""",
|
||||
(attachment_id, chat_id, owner_id, filename, content_type, size_bytes,
|
||||
sha256, width, height, object_key, staging_key, pipeline_version, chat_id, owner_id),
|
||||
).fetchone()
|
||||
return row is not None
|
||||
|
||||
def accept_attachment(
|
||||
self,
|
||||
attachment_id: UUID,
|
||||
job_id: UUID,
|
||||
payload: dict,
|
||||
max_attempts: int,
|
||||
outbox_delay_seconds: float,
|
||||
) -> Optional[Tuple[Attachment, int]]:
|
||||
"""Шаг 3 из 3 (lab5): после успешного PUT в staging — ОДНА транзакция:
|
||||
pending -> queued, запись задания и строки outbox. COMMIT => можно 202.
|
||||
|
||||
Возвращает (вложение, outbox_id) или None, если строку уже забрал сборщик.
|
||||
"""
|
||||
with self.pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
UPDATE attachments a SET state = 'queued', updated_at = clock_timestamp()
|
||||
WHERE a.id = %s AND a.state = 'pending'
|
||||
RETURNING {cols}
|
||||
""".format(cols=ATTACHMENT_COLUMNS),
|
||||
(attachment_id,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO attachment_jobs (job_id, attachment_id, pipeline_version, status,
|
||||
attempt, max_attempts)
|
||||
VALUES (%s, %s, %s, 'queued', 1, %s)
|
||||
""",
|
||||
(job_id, attachment_id, row["pipeline_version"], max_attempts),
|
||||
)
|
||||
outbox_id = conn.execute(
|
||||
"""
|
||||
INSERT INTO job_outbox (job_id, payload, available_at)
|
||||
VALUES (%s, %s, clock_timestamp() + make_interval(secs => %s))
|
||||
RETURNING id
|
||||
""",
|
||||
(job_id, Jsonb(payload), outbox_delay_seconds),
|
||||
).fetchone()[0]
|
||||
conn.execute(
|
||||
"INSERT INTO job_events (job_id, attachment_id, attempt, event, actor) "
|
||||
"VALUES (%s, %s, 1, 'accepted', 'api')",
|
||||
(job_id, attachment_id),
|
||||
)
|
||||
return _attachment(row), outbox_id
|
||||
|
||||
def mark_attachment_ready(self, attachment_id: UUID) -> Optional[Attachment]:
|
||||
"""lab4-совместимость (синхронная загрузка без worker). В lab5 не используется."""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
UPDATE attachments a SET state = 'ready', updated_at = clock_timestamp()
|
||||
WHERE a.id = %s AND a.state = 'pending'
|
||||
RETURNING {cols}
|
||||
""".format(cols=ATTACHMENT_COLUMNS),
|
||||
(attachment_id,),
|
||||
).fetchone()
|
||||
return _attachment(row) if row is not None else None
|
||||
|
||||
def delete_pending_attachment(self, attachment_id: UUID) -> bool:
|
||||
"""Компенсация при ошибке S3 PUT: удалить только своё незавершённое намерение."""
|
||||
with self.pool.connection() as conn:
|
||||
cur = conn.execute(
|
||||
"DELETE FROM attachments WHERE id = %s AND state = 'pending'",
|
||||
(attachment_id,),
|
||||
)
|
||||
return cur.rowcount == 1
|
||||
|
||||
@staticmethod
|
||||
def _variants(conn, attachment_id: UUID, pipeline_version: int) -> List[Variant]:
|
||||
rows = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
SELECT name, content_type, size_bytes, width, height, sha256
|
||||
FROM attachment_variants
|
||||
WHERE attachment_id = %s AND pipeline_version = %s
|
||||
ORDER BY CASE name WHEN 'thumbnail' THEN 1 WHEN 'crop' THEN 2 ELSE 3 END
|
||||
""",
|
||||
(attachment_id, pipeline_version),
|
||||
).fetchall()
|
||||
return [Variant(**r) for r in rows]
|
||||
|
||||
def get_attachment_for_member(self, attachment_id: UUID, user_id: UUID) -> Optional[Tuple[Attachment, str, int]]:
|
||||
"""(метаданные, object_key оригинала, pipeline_version) принятого вложения, если user — участник чата.
|
||||
|
||||
pending (приём не завершён) — как несуществующее. object_key читаем только в ready.
|
||||
"""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.cursor(row_factory=dict_row).execute(
|
||||
"""
|
||||
SELECT {cols}, a.object_key
|
||||
FROM attachments a
|
||||
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = %s
|
||||
WHERE a.id = %s AND a.state <> 'pending'
|
||||
""".format(cols=ATTACHMENT_COLUMNS),
|
||||
(user_id, attachment_id),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
variants = self._variants(conn, attachment_id, row["pipeline_version"]) if row["state"] == "ready" else []
|
||||
return _attachment(row, variants), row["object_key"], row["pipeline_version"]
|
||||
|
||||
def variant_object(self, attachment_id: UUID, pipeline_version: int, name: str) -> Optional[Tuple[str, str, int, str]]:
|
||||
"""(object_key, content_type, size_bytes, sha256) варианта или None."""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT object_key, content_type, size_bytes, sha256 FROM attachment_variants
|
||||
WHERE attachment_id = %s AND pipeline_version = %s AND name = %s
|
||||
""",
|
||||
(attachment_id, pipeline_version, name),
|
||||
).fetchone()
|
||||
return tuple(row) if row else None
|
||||
Reference in New Issue
Block a user