"""Persistent business data and durable Redis sessions; no local state cache.""" import asyncio from datetime import datetime, timezone import hashlib import json import secrets from uuid import UUID, uuid4 from psycopg.errors import ForeignKeyViolation, UniqueViolation from psycopg.rows import dict_row from psycopg_pool import AsyncConnectionPool import redis.asyncio as redis from redis.asyncio.retry import Retry from redis.backoff import NoBackoff from .errors import APIError, invalid, unauthorized from .security import Cursors, bearer, password_hash, password_matches, stamp USER_COLUMNS = "id, username, display_name, created_at" MESSAGE_COLUMNS = "id, chat_id, sender_id, text, created_at, attachment_ids" def public(row): if "attachment_ids" in row: row["attachment_ids"] = [str(x) for x in row["attachment_ids"]] return {key: (str(value) if isinstance(value, UUID) else stamp(value) if isinstance(value, datetime) else value) for key, value in row.items()} class Store: def __init__(self, settings): self.settings = settings self.cursors = Cursors(settings.cursor_key) self.kdf_slots = asyncio.Semaphore(4) self.dummy_hash = password_hash("dummy-password-for-missing-user", b"0" * 16) self.pool = AsyncConnectionPool( settings.database_url, min_size=1, max_size=10, max_waiting=20, timeout=1, open=False, reconnect_timeout=5, check=AsyncConnectionPool.check_connection, kwargs={"row_factory": dict_row, "connect_timeout": 2, "keepalives": 1, "keepalives_idle": 2, "keepalives_interval": 1, "keepalives_count": 2, "tcp_user_timeout": 2000, "options": "-c timezone=UTC -c statement_timeout=2000 -c lock_timeout=1000"}) self.sessions = redis.Redis.from_url( settings.cache_url, decode_responses=True, max_connections=10, socket_connect_timeout=1, socket_timeout=1, retry=Retry(NoBackoff(), 0), retry_on_timeout=False) async def open(self): await self.pool.open() await self.pool.wait(timeout=10) await self.sessions.ping() async def close(self): await self.sessions.aclose() await self.pool.close() async def ready(self): async with self.pool.connection() as conn: await conn.execute("SELECT 1") await self.sessions.ping() async def create_user(self, data): async with self.kdf_slots: encoded = await asyncio.to_thread(password_hash, data.password) try: async with self.pool.connection() as conn: cur = await conn.execute( "INSERT INTO users(id, username, display_name, password_hash) " "VALUES (%s, %s, %s, %s) RETURNING " + USER_COLUMNS, (uuid4(), data.username, data.display_name, encoded)) result = public(await cur.fetchone()) return result except UniqueViolation: raise APIError(409, "conflict", "Username is already taken") from None async def login(self, username, password): async with self.pool.connection() as conn: cur = await conn.execute("SELECT " + USER_COLUMNS + ", password_hash FROM users WHERE username=%s", (username,)) row = await cur.fetchone() async with self.kdf_slots: valid = await asyncio.to_thread(password_matches, password, row["password_hash"] if row else self.dummy_hash) if not valid or row is None: raise unauthorized(basic=True) row.pop("password_hash") token = secrets.token_urlsafe(32) expires_ms = int(datetime.now(timezone.utc).timestamp() * 1000) + self.settings.session_ttl * 1000 await self.sessions.set(self.session_key(token), json.dumps( {"user_id": str(row["id"]), "expires_ms": expires_ms}), pxat=expires_ms) return {"token": token, "token_type": "Bearer", "expires_at": stamp(datetime.fromtimestamp(expires_ms / 1000, timezone.utc)), "user": public(row)} @staticmethod def session_key(token): return "session:" + hashlib.sha256(token.encode("ascii")).hexdigest() async def authenticate(self, header): token = bearer(header) value = await self.sessions.get(self.session_key(token)) if value is None: raise unauthorized() session = json.loads(value) if session["expires_ms"] <= int(datetime.now(timezone.utc).timestamp() * 1000): raise unauthorized() async with self.pool.connection() as conn: cur = await conn.execute("SELECT " + USER_COLUMNS + " FROM users WHERE id=%s", (UUID(session["user_id"]),)) row = await cur.fetchone() if row is None: raise unauthorized() return public(row), token async def logout(self, token): await self.sessions.delete(self.session_key(token)) async def create_chat(self, actor, data): if actor not in data.member_ids: raise invalid("Members must include the current user") try: async with self.pool.connection() as conn: cur = await conn.execute("INSERT INTO chats(id, title) VALUES (%s, %s) " "RETURNING id, title, created_at", (uuid4(), data.title)) row = await cur.fetchone() async with conn.cursor() as cur: await cur.executemany("INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)", [(row["id"], UUID(member)) for member in data.member_ids]) result = public(row) result["member_ids"] = sorted(data.member_ids) return result except ForeignKeyViolation: raise invalid("All members must exist") from None async def accessible_chat(self, conn, actor, chat_id): cur = await conn.execute("""SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s""", (chat_id, UUID(actor))) row = await cur.fetchone() if row is None: raise APIError(404, "not_found", "Chat not found") return row async def get_chat(self, actor, chat_id): async with self.pool.connection() as conn: row = await self.accessible_chat(conn, actor, chat_id) cur = await conn.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id", (chat_id,)) result = public(row) result["member_ids"] = [str(x["user_id"]) for x in await cur.fetchall()] return result async def create_message(self, actor, chat_id, data, key): fingerprint = hashlib.sha256(json.dumps({"text": data.text, "attachment_ids": data.attachment_ids}, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest() async with self.pool.connection() as conn: await self.accessible_chat(conn, actor, chat_id) # Evaluate clock_timestamp AFTER obtaining the per-chat lock. await conn.execute("SELECT id FROM chats WHERE id=%s FOR UPDATE", (chat_id,)) # All replicas share this lock. Replay and side effect commit together. await conn.execute("DELETE FROM message_requests WHERE user_id=%s AND chat_id=%s " "AND request_key=%s AND expires_at <= clock_timestamp()", (UUID(actor), chat_id, key)) replay = await conn.execute("SELECT request_hash, message_id FROM message_requests " "WHERE user_id=%s AND chat_id=%s AND request_key=%s", (UUID(actor), chat_id, key)) previous = await replay.fetchone() if previous: if previous["request_hash"] != fingerprint: raise APIError(409, "conflict", "Idempotency key was used with a different message") saved = await conn.execute("SELECT " + MESSAGE_COLUMNS + " FROM messages WHERE id=%s", (previous["message_id"],)) return public(await saved.fetchone()) for attachment_id in data.attachment_ids: found = await conn.execute("SELECT status FROM attachments WHERE id=%s AND chat_id=%s", (UUID(attachment_id), chat_id)) attachment = await found.fetchone() if attachment is None: raise APIError(404, "not_found", "Attachment not found") if attachment["status"] != "ready": raise APIError(409, "conflict", "Attachment is not ready") cur = await conn.execute("""UPDATE chats SET last_message_at= greatest(clock_timestamp(), last_message_at + interval '1 microsecond') WHERE id=%s RETURNING last_message_at""", (chat_id,)) created_at = (await cur.fetchone())["last_message_at"] cur = await conn.execute("INSERT INTO messages(id, chat_id, sender_id, text, created_at, attachment_ids) " "VALUES (%s, %s, %s, %s, %s, %s) RETURNING " + MESSAGE_COLUMNS, (uuid4(), chat_id, UUID(actor), data.text, created_at, [UUID(x) for x in data.attachment_ids])) result = public(await cur.fetchone()) await conn.execute("INSERT INTO message_requests " "(user_id, chat_id, request_key, request_hash, message_id) VALUES (%s,%s,%s,%s,%s)", (UUID(actor), chat_id, key, fingerprint, UUID(result["id"]))) return result def page(self, rows, scope, limit): items = rows[:limit] return {"items": items, "next_cursor": self.cursors.encode(scope, items[-1]) if len(rows) > limit else None} async def list_messages(self, actor, chat_id, limit, cursor): scope = "messages:" + str(chat_id) boundary = self.cursors.decode(scope, cursor) if cursor is not None else None async with self.pool.connection() as conn: await self.accessible_chat(conn, actor, chat_id) query = "SELECT " + MESSAGE_COLUMNS + " FROM messages WHERE chat_id=%s" params = [chat_id] if boundary: query += " AND (created_at, id) > (%s, %s)" params.extend(boundary) query += " ORDER BY created_at, id LIMIT %s" params.append(limit + 1) cur = await conn.execute(query, params) rows = [public(row) for row in await cur.fetchall()] return self.page(rows, scope, limit) async def list_chats(self, actor, limit, cursor): scope = "chats:" + actor boundary = self.cursors.decode(scope, cursor) if cursor is not None else None query = """SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s""" params = [UUID(actor)] if boundary: query += " AND (c.created_at, c.id) > (%s, %s)" params.extend(boundary) query += " ORDER BY c.created_at, c.id LIMIT %s" params.append(limit + 1) async with self.pool.connection() as conn: cur = await conn.execute(query, params) rows = [public(row) for row in await cur.fetchall()] if rows: ids = [UUID(row["id"]) for row in rows] cur = await conn.execute("SELECT chat_id, user_id FROM chat_members WHERE chat_id=ANY(%s) ORDER BY user_id", (ids,)) members = {row["id"]: [] for row in rows} for member in await cur.fetchall(): members[str(member["chat_id"])].append(str(member["user_id"])) for row in rows: row["member_ids"] = members[row["id"]] return self.page(rows, scope, limit)