775 lines
28 KiB
Python
775 lines
28 KiB
Python
import base64
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import os
|
|
import secrets
|
|
import socket
|
|
import time
|
|
import uuid
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
import psycopg
|
|
import redis
|
|
from psycopg.errors import CheckViolation, ForeignKeyViolation, UniqueViolation
|
|
from psycopg.rows import dict_row
|
|
from psycopg_pool import ConnectionPool, PoolTimeout
|
|
|
|
from errors import AttachmentRejected, DependencyDown, IdempotencyConflict
|
|
from passwords import DUMMY_HASH, hash_password, verify_password
|
|
|
|
LOGGER = logging.getLogger("messenger")
|
|
|
|
POOL_TIMEOUT_SECONDS = 3
|
|
STATEMENT_TIMEOUT_MS = 5000
|
|
LOCK_TIMEOUT_MS = 3000
|
|
REDIS_MAX_CONNECTIONS = 16
|
|
REDIS_SOCKET_TIMEOUT = 2
|
|
SCHEMA_VERSION = "003_attachments"
|
|
|
|
SQL_MESSAGES_FIRST = """
|
|
SELECT id, chat_id, sender_id, body AS text, created_at
|
|
FROM messages
|
|
WHERE chat_id = %s
|
|
ORDER BY created_at, id
|
|
LIMIT %s
|
|
"""
|
|
|
|
SQL_MESSAGES_AFTER = """
|
|
SELECT id, chat_id, sender_id, body AS text, created_at
|
|
FROM messages
|
|
WHERE chat_id = %s
|
|
AND (created_at, id) > (%s, %s)
|
|
ORDER BY created_at, id
|
|
LIMIT %s
|
|
"""
|
|
|
|
SQL_MESSAGE_BY_ID = """
|
|
SELECT id, chat_id, sender_id, body AS text, created_at
|
|
FROM messages
|
|
WHERE id = %s
|
|
"""
|
|
|
|
|
|
def instance_id():
|
|
# Docker без hostname: в контейнере это id контейнера, он не меняется,
|
|
# пока живёт этот контейнер. stop-one.sh находит контейнер по этому значению.
|
|
return socket.gethostname()
|
|
|
|
|
|
def pool_max():
|
|
raw = os.environ.get("POOL_MAX", "10")
|
|
try:
|
|
value = int(raw)
|
|
except ValueError as exc:
|
|
raise RuntimeError("POOL_MAX") from exc
|
|
if not 1 <= value <= 32:
|
|
raise RuntimeError("POOL_MAX")
|
|
return value
|
|
|
|
|
|
def utc_now():
|
|
return datetime.now(timezone.utc)
|
|
|
|
|
|
def dump_time(value):
|
|
if value.tzinfo is None:
|
|
value = value.replace(tzinfo=timezone.utc)
|
|
text = value.astimezone(timezone.utc).isoformat(timespec="microseconds")
|
|
if text.endswith("+00:00"):
|
|
text = text[:-6] + "Z"
|
|
return text
|
|
|
|
|
|
def parse_time(value):
|
|
if not isinstance(value, str) or not value.endswith("Z"):
|
|
raise ValueError("time")
|
|
return datetime.fromisoformat(value[:-1] + "+00:00")
|
|
|
|
|
|
def encode_cursor(scope, created_at, item_id):
|
|
raw = "{}|{}|{}".format(scope, created_at, item_id).encode("utf-8")
|
|
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
|
|
|
|
|
def decode_cursor(cursor, expected_scope):
|
|
if not isinstance(cursor, str) or not cursor or len(cursor) > 512:
|
|
raise ValueError("cursor")
|
|
pad = "=" * (-len(cursor) % 4)
|
|
try:
|
|
decoded = base64.urlsafe_b64decode(cursor + pad).decode("utf-8")
|
|
except (ValueError, UnicodeError) as exc:
|
|
raise ValueError("cursor") from exc
|
|
parts = decoded.split("|")
|
|
if len(parts) != 3:
|
|
raise ValueError("cursor")
|
|
scope, created_at, item_id = parts
|
|
if scope != expected_scope:
|
|
raise ValueError("cursor")
|
|
parse_time(created_at)
|
|
try:
|
|
uuid.UUID(item_id)
|
|
except ValueError as exc:
|
|
raise ValueError("cursor") from exc
|
|
return created_at, item_id
|
|
|
|
|
|
def session_key(token):
|
|
digest = hashlib.sha256(token.encode("utf-8")).hexdigest()
|
|
return "sess:" + digest
|
|
|
|
|
|
def message_fingerprint(text, attachment_ids):
|
|
# Канонический JSON: порядок ключей не важен, пропущенный attachment_ids равен [].
|
|
canonical = json.dumps(
|
|
{"attachment_ids": list(attachment_ids), "text": text},
|
|
ensure_ascii=False,
|
|
sort_keys=True,
|
|
separators=(",", ":"),
|
|
)
|
|
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
|
|
|
|
|
|
def advisory_key(user_id, path, idem_key):
|
|
raw = "\0".join((user_id, "POST", path, idem_key)).encode("utf-8")
|
|
digest = hashlib.sha256(raw).digest()
|
|
return int.from_bytes(digest[:8], "big", signed=True)
|
|
|
|
|
|
def chat_path(chat_id):
|
|
return "/api/v1/chats/" + chat_id + "/messages"
|
|
|
|
|
|
def public_user(row):
|
|
return {
|
|
"id": str(row["id"]),
|
|
"username": row["username"],
|
|
"display_name": row["display_name"],
|
|
"created_at": dump_time(row["created_at"]),
|
|
}
|
|
|
|
|
|
def public_message(row, attachment_ids=None):
|
|
return {
|
|
"id": str(row["id"]),
|
|
"chat_id": str(row["chat_id"]),
|
|
"sender_id": str(row["sender_id"]),
|
|
"text": row["text"],
|
|
"attachment_ids": list(attachment_ids or []),
|
|
"created_at": dump_time(row["created_at"]),
|
|
}
|
|
|
|
|
|
def public_attachment(row):
|
|
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": int(row["size_bytes"]),
|
|
"sha256": row["sha256"],
|
|
"status": "ready",
|
|
"variants": [],
|
|
"error_code": None,
|
|
"created_at": dump_time(row["created_at"]),
|
|
"updated_at": dump_time(row["updated_at"]),
|
|
}
|
|
|
|
|
|
def public_chat(row, member_ids=None):
|
|
members = member_ids if member_ids is not None else row["member_ids"]
|
|
return {
|
|
"id": str(row["id"]),
|
|
"title": row["title"],
|
|
"member_ids": [str(item) for item in members],
|
|
"created_at": dump_time(row["created_at"]),
|
|
}
|
|
|
|
|
|
def read_secret_file(path):
|
|
with open(path, encoding="utf-8") as handle:
|
|
return handle.read().strip()
|
|
|
|
|
|
def _db_down(exc):
|
|
raise DependencyDown() from exc
|
|
|
|
|
|
class Store:
|
|
def __init__(self):
|
|
self.pool = None
|
|
self.redis = None
|
|
self.ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
|
self.idem_ttl = int(os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400"))
|
|
self.pool_size = pool_max()
|
|
self.shutting_down = False
|
|
if self.ttl < 1 or self.idem_ttl < 1:
|
|
raise RuntimeError("TTL")
|
|
kind = os.environ.get("SESSION_STORE", "redis").strip().lower()
|
|
if kind != "redis":
|
|
raise RuntimeError("SESSION_STORE")
|
|
|
|
def database_url(self):
|
|
path = os.environ.get("DATABASE_URL_FILE")
|
|
if path:
|
|
return read_secret_file(path)
|
|
url = os.environ.get("DATABASE_URL", "").strip()
|
|
if not url:
|
|
raise RuntimeError("DATABASE_URL_FILE")
|
|
return url
|
|
|
|
def redis_url(self):
|
|
path = os.environ.get("CACHE_URL_FILE")
|
|
if path:
|
|
return read_secret_file(path)
|
|
url = os.environ.get("CACHE_URL", "").strip()
|
|
if not url:
|
|
raise RuntimeError("CACHE_URL_FILE")
|
|
return url
|
|
|
|
def startup(self):
|
|
conninfo = self.database_url()
|
|
self._wait_schema(conninfo)
|
|
self.pool = ConnectionPool(
|
|
conninfo,
|
|
min_size=1,
|
|
max_size=self.pool_size,
|
|
timeout=POOL_TIMEOUT_SECONDS,
|
|
max_waiting=64,
|
|
max_lifetime=300,
|
|
kwargs={
|
|
"connect_timeout": POOL_TIMEOUT_SECONDS,
|
|
"row_factory": dict_row,
|
|
"application_name": "mtusi-lab4-" + instance_id(),
|
|
"options": "-c statement_timeout={} -c lock_timeout={} -c idle_in_transaction_session_timeout=15000".format(
|
|
STATEMENT_TIMEOUT_MS,
|
|
LOCK_TIMEOUT_MS,
|
|
),
|
|
},
|
|
open=True,
|
|
)
|
|
pool = redis.ConnectionPool.from_url(
|
|
self.redis_url(),
|
|
max_connections=REDIS_MAX_CONNECTIONS,
|
|
socket_timeout=REDIS_SOCKET_TIMEOUT,
|
|
socket_connect_timeout=REDIS_SOCKET_TIMEOUT,
|
|
health_check_interval=30,
|
|
decode_responses=True,
|
|
)
|
|
self.redis = redis.Redis(connection_pool=pool)
|
|
self._wait_redis()
|
|
self._wait_bucket()
|
|
LOGGER.info("ready instance=%s ttl=%s pool_max=%s", instance_id(), self.ttl, self.pool_size)
|
|
|
|
def shutdown(self):
|
|
self.shutting_down = True
|
|
if self.pool is not None:
|
|
self.pool.close()
|
|
if self.redis is not None:
|
|
self.redis.close()
|
|
|
|
def ready(self):
|
|
if self.shutting_down or self.pool is None or self.redis is None:
|
|
return False
|
|
try:
|
|
with self.pool.connection(timeout=POOL_TIMEOUT_SECONDS) as conn:
|
|
row = conn.execute(
|
|
"SELECT 1 FROM schema_migrations WHERE version = %s",
|
|
(SCHEMA_VERSION,),
|
|
).fetchone()
|
|
if row is None:
|
|
return False
|
|
self.redis.ping()
|
|
from blobs import bucket_ready
|
|
|
|
if not bucket_ready():
|
|
return False
|
|
except Exception:
|
|
LOGGER.warning("ready check failed")
|
|
return False
|
|
return True
|
|
|
|
def _wait_redis(self):
|
|
last = None
|
|
for _ in range(60):
|
|
try:
|
|
self.redis.ping()
|
|
return
|
|
except redis.RedisError as exc:
|
|
last = type(exc).__name__
|
|
time.sleep(1)
|
|
LOGGER.error("redis not ready: %s", last)
|
|
raise SystemExit(1)
|
|
|
|
def _wait_schema(self, conninfo):
|
|
# Схему накатывает сервис migrate. Реплики только ждут её, не применяют сами.
|
|
last = None
|
|
for _ in range(90):
|
|
try:
|
|
with psycopg.connect(conninfo, connect_timeout=POOL_TIMEOUT_SECONDS, row_factory=dict_row) as conn:
|
|
row = conn.execute(
|
|
"SELECT 1 FROM schema_migrations WHERE version = %s",
|
|
(SCHEMA_VERSION,),
|
|
).fetchone()
|
|
if row is not None:
|
|
return
|
|
last = "migration missing"
|
|
except psycopg.Error as exc:
|
|
last = type(exc).__name__
|
|
time.sleep(1)
|
|
LOGGER.error("schema not ready: %s", last)
|
|
raise SystemExit(1)
|
|
|
|
def _wait_bucket(self):
|
|
from blobs import bucket_ready
|
|
|
|
for _ in range(60):
|
|
if bucket_ready():
|
|
return
|
|
time.sleep(1)
|
|
LOGGER.error("object storage not ready")
|
|
raise SystemExit(1)
|
|
|
|
def _connect(self):
|
|
try:
|
|
return self.pool.connection(timeout=POOL_TIMEOUT_SECONDS)
|
|
except PoolTimeout as exc:
|
|
_db_down(exc)
|
|
|
|
def create_user(self, username, display_name, password):
|
|
password_hash = hash_password(password)
|
|
user_id = uuid.uuid4()
|
|
created = utc_now()
|
|
try:
|
|
with self._connect() as conn:
|
|
with conn.transaction():
|
|
row = conn.execute(
|
|
"""
|
|
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
|
VALUES (%s, %s, %s, %s, %s)
|
|
ON CONFLICT (username) DO NOTHING
|
|
RETURNING id, username, display_name, created_at
|
|
""",
|
|
(user_id, username, display_name, password_hash, created),
|
|
).fetchone()
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
if row is None:
|
|
return None
|
|
return public_user(row)
|
|
|
|
def login(self, username, password):
|
|
try:
|
|
with self._connect() as conn:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT id, username, display_name, password_hash, created_at
|
|
FROM users
|
|
WHERE username = %s
|
|
""",
|
|
(username,),
|
|
).fetchone()
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
if row is None:
|
|
verify_password(password, DUMMY_HASH)
|
|
return None
|
|
if not verify_password(password, row["password_hash"]):
|
|
return None
|
|
return self._issue(public_user(row))
|
|
|
|
def _issue(self, user):
|
|
token = secrets.token_urlsafe(32)
|
|
expires = utc_now() + timedelta(seconds=self.ttl)
|
|
payload = json.dumps(
|
|
{"user_id": user["id"], "expires_at": dump_time(expires)},
|
|
separators=(",", ":"),
|
|
)
|
|
# pxat — абсолютное время. Рестарт Redis не сдвигает срок.
|
|
# В значении тоже лежит expires_at: даже если TTL ключа разъедется, сессия кончится вовремя.
|
|
try:
|
|
self.redis.set(session_key(token), payload, pxat=int(expires.timestamp() * 1000))
|
|
except redis.RedisError as exc:
|
|
raise DependencyDown() from exc
|
|
return {
|
|
"token": token,
|
|
"token_type": "Bearer",
|
|
"expires_at": dump_time(expires),
|
|
"user": user,
|
|
}
|
|
|
|
def user_for_token(self, token):
|
|
key = session_key(token)
|
|
try:
|
|
raw = self.redis.get(key)
|
|
except redis.RedisError as exc:
|
|
raise DependencyDown() from exc
|
|
if not raw:
|
|
return None
|
|
try:
|
|
payload = json.loads(raw)
|
|
expires = parse_time(payload["expires_at"])
|
|
user_id = payload["user_id"]
|
|
uuid.UUID(user_id)
|
|
except (ValueError, KeyError, TypeError):
|
|
return None
|
|
if utc_now() >= expires:
|
|
try:
|
|
self.redis.delete(key)
|
|
except redis.RedisError as exc:
|
|
raise DependencyDown() from exc
|
|
return None
|
|
try:
|
|
with self._connect() as conn:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT id, username, display_name, created_at
|
|
FROM users
|
|
WHERE id = %s
|
|
""",
|
|
(user_id,),
|
|
).fetchone()
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
if row is None:
|
|
return None
|
|
return public_user(row)
|
|
|
|
def revoke(self, token):
|
|
try:
|
|
deleted = self.redis.delete(session_key(token))
|
|
except redis.RedisError as exc:
|
|
raise DependencyDown() from exc
|
|
return deleted == 1
|
|
|
|
def create_chat(self, title, member_ids, caller_id):
|
|
try:
|
|
caller_uuid = uuid.UUID(str(caller_id))
|
|
member_uuids = []
|
|
seen = set()
|
|
for item in member_ids:
|
|
member_uuid = uuid.UUID(str(item))
|
|
if member_uuid in seen:
|
|
raise ValueError("members")
|
|
seen.add(member_uuid)
|
|
member_uuids.append(member_uuid)
|
|
except ValueError as exc:
|
|
raise ValueError("members") from exc
|
|
if caller_uuid not in seen:
|
|
raise ValueError("members")
|
|
chat_id = uuid.uuid4()
|
|
created = utc_now()
|
|
canonical_members = [str(item) for item in member_uuids]
|
|
try:
|
|
with self._connect() as conn:
|
|
try:
|
|
with conn.transaction():
|
|
conn.execute(
|
|
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
|
|
(chat_id, title, created),
|
|
)
|
|
for ordinal, member_id in enumerate(member_uuids):
|
|
conn.execute(
|
|
"""
|
|
INSERT INTO chat_members (chat_id, user_id, ordinal)
|
|
VALUES (%s, %s, %s)
|
|
""",
|
|
(chat_id, member_id, ordinal),
|
|
)
|
|
row = conn.execute(
|
|
"SELECT id, title, created_at FROM chats WHERE id = %s",
|
|
(chat_id,),
|
|
).fetchone()
|
|
except ForeignKeyViolation as exc:
|
|
raise ValueError("members") from exc
|
|
except UniqueViolation as exc:
|
|
raise ValueError("members") from exc
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
return public_chat(row, canonical_members)
|
|
|
|
def _member(self, conn, chat_id, user_id):
|
|
return conn.execute(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
|
(chat_id, user_id),
|
|
).fetchone()
|
|
|
|
def get_chat(self, chat_id, user_id):
|
|
try:
|
|
with self._connect() as conn:
|
|
if self._member(conn, chat_id, user_id) is None:
|
|
return None
|
|
row = conn.execute(
|
|
"""
|
|
SELECT c.id, c.title, c.created_at,
|
|
array_agg(m.user_id ORDER BY m.ordinal) AS member_ids
|
|
FROM chats c
|
|
JOIN chat_members m ON m.chat_id = c.id
|
|
WHERE c.id = %s
|
|
GROUP BY c.id
|
|
""",
|
|
(chat_id,),
|
|
).fetchone()
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
if row is None:
|
|
return None
|
|
return public_chat(row)
|
|
|
|
def list_chats(self, user_id, limit, cursor):
|
|
after = None
|
|
if cursor is not None:
|
|
created_at, item_id = decode_cursor(cursor, "chats:" + user_id)
|
|
after = (parse_time(created_at), uuid.UUID(item_id))
|
|
sql = """
|
|
SELECT c.id, c.title, c.created_at,
|
|
array_agg(m.user_id ORDER BY m.ordinal) AS member_ids
|
|
FROM chats c
|
|
JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = %s
|
|
JOIN chat_members m ON m.chat_id = c.id
|
|
"""
|
|
params = [user_id]
|
|
if after is not None:
|
|
sql += " WHERE (c.created_at, c.id) > (%s, %s)"
|
|
params.extend(after)
|
|
sql += " GROUP BY c.id ORDER BY c.created_at, c.id LIMIT %s"
|
|
params.append(limit + 1)
|
|
try:
|
|
with self._connect() as conn:
|
|
rows = conn.execute(sql, params).fetchall()
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
page = [public_chat(row) for row in rows[:limit]]
|
|
if len(rows) > limit and page:
|
|
last = page[-1]
|
|
return page, encode_cursor("chats:" + user_id, last["created_at"], last["id"])
|
|
return page, None
|
|
|
|
def _attachment_ids(self, conn, message_ids):
|
|
if not message_ids:
|
|
return {}
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT message_id, attachment_id
|
|
FROM message_attachments
|
|
WHERE message_id = ANY(%s::uuid[])
|
|
ORDER BY ordinal
|
|
""",
|
|
(list(message_ids),),
|
|
).fetchall()
|
|
found = {}
|
|
for row in rows:
|
|
found.setdefault(str(row["message_id"]), []).append(str(row["attachment_id"]))
|
|
return found
|
|
|
|
def is_member(self, chat_id, user_id):
|
|
try:
|
|
with self._connect() as conn:
|
|
return self._member(conn, chat_id, user_id) is not None
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
|
|
def save_attachment(self, chat_id, owner_id, filename, content_type, data):
|
|
from blobs import delete_quiet, object_key, put_bytes
|
|
|
|
attachment_id = uuid.uuid4()
|
|
key = object_key(chat_id, attachment_id)
|
|
digest = hashlib.sha256(data).hexdigest()
|
|
created = utc_now()
|
|
put_bytes(key, data, content_type, created)
|
|
try:
|
|
with self._connect() as conn:
|
|
with conn.transaction():
|
|
if self._member(conn, chat_id, owner_id) is None:
|
|
raise LookupError("chat")
|
|
row = conn.execute(
|
|
"""
|
|
INSERT INTO attachments (
|
|
id, chat_id, owner_id, filename, content_type,
|
|
size_bytes, sha256, object_key, status, created_at, updated_at
|
|
)
|
|
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 'ready', %s, %s)
|
|
RETURNING id, chat_id, owner_id, filename, content_type,
|
|
size_bytes, sha256, created_at, updated_at
|
|
""",
|
|
(
|
|
attachment_id,
|
|
chat_id,
|
|
owner_id,
|
|
filename,
|
|
content_type,
|
|
len(data),
|
|
digest,
|
|
key,
|
|
created,
|
|
created,
|
|
),
|
|
).fetchone()
|
|
except (LookupError, ForeignKeyViolation):
|
|
delete_quiet(key)
|
|
return None
|
|
except psycopg.OperationalError as exc:
|
|
delete_quiet(key)
|
|
_db_down(exc)
|
|
except Exception:
|
|
delete_quiet(key)
|
|
raise
|
|
return public_attachment(row)
|
|
|
|
def get_attachment(self, attachment_id, user_id):
|
|
try:
|
|
with self._connect() as conn:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type,
|
|
a.size_bytes, a.sha256, a.created_at, a.updated_at
|
|
FROM attachments a
|
|
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = %s
|
|
WHERE a.id = %s
|
|
""",
|
|
(user_id, attachment_id),
|
|
).fetchone()
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
if row is None:
|
|
return None
|
|
return public_attachment(row)
|
|
|
|
def open_attachment(self, attachment_id, user_id):
|
|
try:
|
|
with self._connect() as conn:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT a.object_key, a.content_type, a.size_bytes
|
|
FROM attachments a
|
|
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = %s
|
|
WHERE a.id = %s
|
|
""",
|
|
(user_id, attachment_id),
|
|
).fetchone()
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
if row is None:
|
|
return None
|
|
return {
|
|
"object_key": row["object_key"],
|
|
"content_type": row["content_type"],
|
|
"size_bytes": int(row["size_bytes"]),
|
|
}
|
|
|
|
def add_message(self, chat_id, sender_id, text, idem_key, attachment_ids):
|
|
# Один ключ сериализуется между репликами через advisory lock в той же
|
|
# транзакции, где INSERT сообщения. Откат не оставляет ключ занятым.
|
|
path = chat_path(chat_id)
|
|
digest = message_fingerprint(text, attachment_ids)
|
|
lock_key = advisory_key(sender_id, path, idem_key)
|
|
message_id = uuid.uuid4()
|
|
try:
|
|
with self._connect() as conn:
|
|
with conn.transaction():
|
|
# Иначе lock_timeout сессии (3 с) оборвёт очередь одинаковых ключей.
|
|
conn.execute("SET LOCAL lock_timeout = '15s'")
|
|
conn.execute("SELECT pg_advisory_xact_lock(%s)", (lock_key,))
|
|
if self._member(conn, chat_id, sender_id) is None:
|
|
return None
|
|
existing = conn.execute(
|
|
"""
|
|
SELECT request_hash, message_id,
|
|
created_at >= now() - make_interval(secs => %s) AS fresh
|
|
FROM idempotency_keys
|
|
WHERE user_id = %s AND http_method = 'POST'
|
|
AND request_path = %s AND idem_key = %s
|
|
""",
|
|
(self.idem_ttl, sender_id, path, idem_key),
|
|
).fetchone()
|
|
if existing is not None and existing["fresh"]:
|
|
if existing["request_hash"] != digest:
|
|
raise IdempotencyConflict()
|
|
row = conn.execute(SQL_MESSAGE_BY_ID, (existing["message_id"],)).fetchone()
|
|
if row is None:
|
|
raise RuntimeError("idempotency target missing")
|
|
linked = self._attachment_ids(conn, [row["id"]]).get(str(row["id"]), [])
|
|
return public_message(row, linked)
|
|
if existing is not None:
|
|
conn.execute(
|
|
"""
|
|
DELETE FROM idempotency_keys
|
|
WHERE user_id = %s AND http_method = 'POST'
|
|
AND request_path = %s AND idem_key = %s
|
|
""",
|
|
(sender_id, path, idem_key),
|
|
)
|
|
if attachment_ids:
|
|
found = conn.execute(
|
|
"""
|
|
SELECT id, chat_id, status
|
|
FROM attachments
|
|
WHERE id = ANY(%s::uuid[])
|
|
""",
|
|
(list(attachment_ids),),
|
|
).fetchall()
|
|
by_id = {str(item["id"]): item for item in found}
|
|
for attachment_id in attachment_ids:
|
|
item = by_id.get(attachment_id)
|
|
if item is None or str(item["chat_id"]) != chat_id:
|
|
return None
|
|
if item["status"] != "ready":
|
|
raise AttachmentRejected()
|
|
row = conn.execute(
|
|
"""
|
|
INSERT INTO messages (id, chat_id, sender_id, body, created_at)
|
|
VALUES (%s, %s, %s, %s, clock_timestamp())
|
|
RETURNING id, chat_id, sender_id, body AS text, created_at
|
|
""",
|
|
(message_id, chat_id, sender_id, text),
|
|
).fetchone()
|
|
for ordinal, attachment_id in enumerate(attachment_ids):
|
|
conn.execute(
|
|
"""
|
|
INSERT INTO message_attachments (message_id, attachment_id, ordinal)
|
|
VALUES (%s, %s, %s)
|
|
""",
|
|
(row["id"], attachment_id, ordinal),
|
|
)
|
|
conn.execute(
|
|
"""
|
|
INSERT INTO idempotency_keys (
|
|
user_id, http_method, request_path, idem_key,
|
|
request_hash, message_id, created_at
|
|
)
|
|
VALUES (%s, 'POST', %s, %s, %s, %s, clock_timestamp())
|
|
""",
|
|
(sender_id, path, idem_key, digest, row["id"]),
|
|
)
|
|
return public_message(row, attachment_ids)
|
|
except CheckViolation as exc:
|
|
raise ValueError("message") from exc
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
|
|
def list_messages(self, chat_id, user_id, limit, cursor):
|
|
after = None
|
|
if cursor is not None:
|
|
created_at, item_id = decode_cursor(cursor, chat_id)
|
|
after = (parse_time(created_at), uuid.UUID(item_id))
|
|
try:
|
|
with self._connect() as conn:
|
|
if self._member(conn, chat_id, user_id) is None:
|
|
return None
|
|
if after is None:
|
|
rows = conn.execute(SQL_MESSAGES_FIRST, (chat_id, limit + 1)).fetchall()
|
|
else:
|
|
rows = conn.execute(
|
|
SQL_MESSAGES_AFTER,
|
|
(chat_id, after[0], after[1], limit + 1),
|
|
).fetchall()
|
|
linked = self._attachment_ids(conn, [row["id"] for row in rows[:limit]])
|
|
except psycopg.OperationalError as exc:
|
|
_db_down(exc)
|
|
page = [public_message(row, linked.get(str(row["id"]), [])) for row in rows[:limit]]
|
|
if len(rows) > limit and page:
|
|
last = page[-1]
|
|
return page, encode_cursor(chat_id, last["created_at"], last["id"])
|
|
return page, None
|