forked from mtusi2026/mtusi2026lab5
340 lines
13 KiB
Python
340 lines
13 KiB
Python
"""PostgreSQL adapter: bounded connections, parameterized SQL, commit before return."""
|
|
|
|
import hashlib
|
|
import json
|
|
from contextlib import contextmanager, nullcontext
|
|
from datetime import datetime
|
|
from typing import Protocol
|
|
|
|
import psycopg
|
|
from psycopg import errors
|
|
from psycopg.rows import dict_row
|
|
from psycopg_pool import ConnectionPool, PoolTimeout, TooManyRequests
|
|
|
|
from messenger.domain import (
|
|
Attachment,
|
|
Chat,
|
|
DomainError,
|
|
HistoryKey,
|
|
Message,
|
|
User,
|
|
invalid,
|
|
new_id,
|
|
)
|
|
|
|
|
|
def stamp(value: datetime) -> str:
|
|
return value.isoformat(timespec="microseconds").replace("+00:00", "Z")
|
|
|
|
|
|
def user_value(row) -> User:
|
|
return User(str(row["id"]), row["username"], row["display_name"], stamp(row["created_at"]))
|
|
|
|
|
|
def chat_value(row) -> Chat:
|
|
return Chat(
|
|
str(row["id"]),
|
|
row["title"],
|
|
tuple(str(x) for x in row["member_ids"]),
|
|
stamp(row["created_at"]),
|
|
)
|
|
|
|
|
|
def message_value(row) -> Message:
|
|
return Message(
|
|
str(row["id"]),
|
|
str(row["chat_id"]),
|
|
str(row["sender_id"]),
|
|
row["text"],
|
|
stamp(row["created_at"]),
|
|
tuple(str(x) for x in row.get("attachment_ids", ())),
|
|
)
|
|
|
|
|
|
def attachment_value(row) -> Attachment:
|
|
return Attachment(
|
|
*(str(row[k]) for k in ("id", "chat_id", "owner_id")),
|
|
row["filename"],
|
|
row["content_type"],
|
|
row["size_bytes"],
|
|
row["sha256"],
|
|
stamp(row["created_at"]),
|
|
stamp(row["updated_at"]),
|
|
row["storage_state"],
|
|
tuple(
|
|
{k: v for k, v in item.items() if k != "object_key"} for item in row.get("variants", [])
|
|
),
|
|
row.get("error_code"),
|
|
)
|
|
|
|
|
|
class Repository(Protocol):
|
|
def get_user(self, user_id: str) -> User | None: ...
|
|
def add_chat(self, title: str, member_ids: tuple[str, ...]) -> Chat: ...
|
|
def get_chat(self, chat_id: str) -> Chat | None: ...
|
|
def page_chats(self, user_id: str, after: HistoryKey | None, limit: int) -> list[Chat]: ...
|
|
def add_message(self, chat_id: str, sender_id: str, text: str) -> Message: ...
|
|
def idempotent_message(
|
|
self,
|
|
chat_id: str,
|
|
sender_id: str,
|
|
text: str,
|
|
key: str,
|
|
attachment_ids: tuple[str, ...] = (),
|
|
) -> Message: ...
|
|
def page_messages(
|
|
self, chat_id: str, after: HistoryKey | None, limit: int
|
|
) -> list[Message]: ...
|
|
|
|
|
|
CHAT_COLUMNS = """c.id, c.title, c.created_at,
|
|
ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY position) AS member_ids"""
|
|
|
|
|
|
MESSAGE_COLUMNS = """m.*, ARRAY(SELECT attachment_id FROM message_attachments
|
|
WHERE message_id=m.id ORDER BY position) AS attachment_ids"""
|
|
|
|
|
|
class PostgresRepository:
|
|
def __init__(
|
|
self,
|
|
conninfo: str,
|
|
pool_size: int = 8,
|
|
idempotency_ttl: int = 86400,
|
|
read_autocommit: bool = True,
|
|
):
|
|
self.read_autocommit = read_autocommit
|
|
self.idempotency_ttl = idempotency_ttl
|
|
self.pool = ConnectionPool(
|
|
conninfo,
|
|
min_size=1,
|
|
max_size=pool_size,
|
|
timeout=1,
|
|
max_waiting=32,
|
|
open=False,
|
|
check=ConnectionPool.check_connection,
|
|
kwargs={
|
|
"row_factory": dict_row,
|
|
"autocommit": True,
|
|
"connect_timeout": 2,
|
|
"options": "-c statement_timeout=2500 -c lock_timeout=1000 "
|
|
"-c idle_in_transaction_session_timeout=5000 -c timezone=UTC",
|
|
},
|
|
)
|
|
|
|
def open(self):
|
|
self.pool.open(wait=True, timeout=15)
|
|
|
|
def close(self):
|
|
self.pool.close(timeout=5)
|
|
|
|
@contextmanager
|
|
def connection(self, *, write: bool = False):
|
|
try:
|
|
with self.pool.connection() as conn:
|
|
transaction = (
|
|
conn.transaction() if write or not self.read_autocommit else nullcontext()
|
|
)
|
|
with transaction:
|
|
yield conn
|
|
except (
|
|
psycopg.OperationalError,
|
|
psycopg.InterfaceError,
|
|
PoolTimeout,
|
|
TooManyRequests,
|
|
errors.QueryCanceled,
|
|
errors.LockNotAvailable,
|
|
):
|
|
raise DomainError(503, "unavailable", "Хранилище временно недоступно") from None
|
|
|
|
def ready(self):
|
|
with self.connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT count(*) AS n FROM schema_migrations "
|
|
"WHERE version IN "
|
|
"('001_initial','002_idempotency','003_attachments',"
|
|
"'004_pipeline','005_upload_handoff')"
|
|
).fetchone()
|
|
if row["n"] != 5:
|
|
raise DomainError(503, "unavailable", "Схема ещё не готова")
|
|
|
|
def add_user(self, username: str, display_name: str, password_hash: str) -> User:
|
|
try:
|
|
with self.connection(write=True) as conn:
|
|
row = conn.execute(
|
|
"INSERT INTO users (id,username,display_name,password_hash) "
|
|
"VALUES (%s,%s,%s,%s) RETURNING *",
|
|
(new_id(), username, display_name, password_hash),
|
|
).fetchone()
|
|
return user_value(row)
|
|
except errors.UniqueViolation:
|
|
raise DomainError(409, "conflict", "Имя пользователя уже занято") from None
|
|
|
|
def credentials(self, username: str):
|
|
with self.connection() as conn:
|
|
row = conn.execute("SELECT * FROM users WHERE username=%s", (username,)).fetchone()
|
|
return (user_value(row), row["password_hash"]) if row else None
|
|
|
|
def get_user(self, user_id: str) -> User | None:
|
|
with self.connection() as conn:
|
|
row = conn.execute("SELECT * FROM users WHERE id=%s", (user_id,)).fetchone()
|
|
return user_value(row) if row else None
|
|
|
|
def add_chat(self, title: str, member_ids: tuple[str, ...]) -> Chat:
|
|
try:
|
|
with self.connection(write=True) as conn:
|
|
row = conn.execute(
|
|
"INSERT INTO chats (id,title) VALUES (%s,%s) RETURNING *", (new_id(), title)
|
|
).fetchone()
|
|
with conn.cursor() as cur:
|
|
cur.executemany(
|
|
"INSERT INTO chat_members (chat_id,user_id,position) VALUES (%s,%s,%s)",
|
|
[(row["id"], member, i) for i, member in enumerate(member_ids)],
|
|
)
|
|
return Chat(str(row["id"]), title, member_ids, stamp(row["created_at"]))
|
|
except errors.ForeignKeyViolation:
|
|
raise invalid("Указан неизвестный участник") from None
|
|
|
|
def get_chat(self, chat_id: str) -> Chat | None:
|
|
with self.connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT " + CHAT_COLUMNS + " FROM chats c WHERE c.id=%s", (chat_id,)
|
|
).fetchone()
|
|
return chat_value(row) if row else None
|
|
|
|
def page_chats(self, user_id: str, after: HistoryKey | None, limit: int) -> list[Chat]:
|
|
condition = " AND (c.created_at,c.id) > (%s::timestamptz,%s::uuid)" if after else ""
|
|
params = (user_id, *after, limit) if after else (user_id, limit)
|
|
with self.connection() as conn:
|
|
rows = conn.execute(
|
|
"SELECT " + CHAT_COLUMNS + " FROM chats c WHERE EXISTS "
|
|
"(SELECT 1 FROM chat_members m WHERE m.chat_id=c.id AND m.user_id=%s)"
|
|
+ condition
|
|
+ " ORDER BY c.created_at,c.id LIMIT %s",
|
|
params,
|
|
).fetchall()
|
|
return [chat_value(row) for row in rows]
|
|
|
|
def add_message(self, chat_id: str, sender_id: str, text: str) -> Message:
|
|
with self.connection(write=True) as conn:
|
|
row = conn.execute(
|
|
"INSERT INTO messages (id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *",
|
|
(new_id(), chat_id, sender_id, text),
|
|
).fetchone()
|
|
return message_value(row)
|
|
|
|
def page_messages(self, chat_id: str, after: HistoryKey | None, limit: int) -> list[Message]:
|
|
condition = " AND (m.created_at,m.id) > (%s::timestamptz,%s::uuid)" if after else ""
|
|
params = (chat_id, *after, limit) if after else (chat_id, limit)
|
|
with self.connection() as conn:
|
|
rows = conn.execute(
|
|
"SELECT "
|
|
+ MESSAGE_COLUMNS
|
|
+ " FROM messages m WHERE m.chat_id=%s"
|
|
+ condition
|
|
+ " ORDER BY m.created_at,m.id LIMIT %s",
|
|
params,
|
|
).fetchall()
|
|
return [message_value(row) for row in rows]
|
|
|
|
def idempotent_message(
|
|
self,
|
|
chat_id: str,
|
|
sender_id: str,
|
|
text: str,
|
|
key: str,
|
|
attachment_ids: tuple[str, ...] = (),
|
|
) -> Message:
|
|
scope = json.dumps([sender_id, "POST", chat_id, key], separators=(",", ":"))
|
|
lock = int.from_bytes(hashlib.sha256(scope.encode()).digest()[:8], "big", signed=True)
|
|
payload = json.dumps(
|
|
{"text": text, "attachment_ids": list(attachment_ids)},
|
|
sort_keys=True,
|
|
separators=(",", ":"),
|
|
ensure_ascii=False,
|
|
)
|
|
digest = hashlib.sha256(payload.encode()).digest()
|
|
with self.connection(write=True) as conn:
|
|
conn.execute("SELECT pg_advisory_xact_lock(%s)", (lock,))
|
|
previous = conn.execute(
|
|
"SELECT r.payload_hash," + MESSAGE_COLUMNS + " FROM message_requests r "
|
|
"JOIN messages m ON m.id=r.response_message_id "
|
|
"WHERE r.user_id=%s AND r.http_method='POST' AND r.chat_id=%s "
|
|
"AND r.idempotency_key=%s AND r.expires_at > clock_timestamp()",
|
|
(sender_id, chat_id, key),
|
|
).fetchone()
|
|
if previous:
|
|
if previous["payload_hash"] != digest:
|
|
raise DomainError(409, "conflict", "Ключ уже использован с другим сообщением")
|
|
return message_value(previous)
|
|
conn.execute(
|
|
"DELETE FROM message_requests WHERE user_id=%s AND http_method='POST' "
|
|
"AND chat_id=%s AND idempotency_key=%s",
|
|
(sender_id, chat_id, key),
|
|
)
|
|
if attachment_ids:
|
|
rows = conn.execute(
|
|
"SELECT id,storage_state FROM attachments WHERE chat_id=%s "
|
|
"AND id=ANY(%s::uuid[]) ORDER BY id FOR UPDATE",
|
|
(chat_id, list(attachment_ids)),
|
|
).fetchall()
|
|
if len(rows) != len(attachment_ids):
|
|
raise DomainError(404, "not_found", "Объект не найден")
|
|
if any(row["storage_state"] == "failed" for row in rows):
|
|
raise DomainError(409, "conflict", "Вложение пока недоступно")
|
|
message = message_value(
|
|
conn.execute(
|
|
"INSERT INTO messages (id,chat_id,sender_id,text) "
|
|
"VALUES (%s,%s,%s,%s) RETURNING *",
|
|
(new_id(), chat_id, sender_id, text),
|
|
).fetchone()
|
|
)
|
|
for position, attachment in enumerate(attachment_ids):
|
|
conn.execute(
|
|
"INSERT INTO message_attachments VALUES (%s,%s,%s,%s)",
|
|
(message.id, chat_id, attachment, position),
|
|
)
|
|
message = Message(
|
|
message.id,
|
|
message.chat_id,
|
|
message.sender_id,
|
|
message.text,
|
|
message.created_at,
|
|
attachment_ids,
|
|
)
|
|
self._save_request(conn, sender_id, chat_id, key, digest, message.id)
|
|
return message
|
|
|
|
def _save_request(self, conn, user_id, chat_id, key, digest, message_id):
|
|
conn.execute(
|
|
"INSERT INTO message_requests "
|
|
"(user_id,chat_id,idempotency_key,payload_hash,response_message_id,expires_at) "
|
|
"VALUES (%s,%s,%s,%s,%s,clock_timestamp()+make_interval(secs => %s))",
|
|
(user_id, chat_id, key, digest, message_id, self.idempotency_ttl),
|
|
)
|
|
|
|
def create_session(self, token_hash: bytes, user_id: str, ttl: int) -> str:
|
|
with self.connection(write=True) as conn:
|
|
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),
|
|
).fetchone()
|
|
return stamp(row["expires_at"])
|
|
|
|
def active_session(self, token_hash: bytes):
|
|
with self.connection() as conn:
|
|
return conn.execute(
|
|
"SELECT user_id,expires_at,clock_timestamp() AS checked_at FROM sessions "
|
|
"WHERE token_hash=%s AND expires_at > clock_timestamp()",
|
|
(token_hash,),
|
|
).fetchone()
|
|
|
|
def revoke_session(self, token_hash: bytes):
|
|
with self.connection(write=True) as conn:
|
|
conn.execute("DELETE FROM sessions WHERE token_hash=%s", (token_hash,))
|
|
|
|
def attachment(self, id):
|
|
with self.connection() as conn:
|
|
return conn.execute("SELECT * FROM attachments WHERE id=%s", (id,)).fetchone()
|