forked from mtusi2026/mtusi2026lab3
229 lines
11 KiB
Python
229 lines
11 KiB
Python
"""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"
|
|
|
|
|
|
def public(row):
|
|
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},
|
|
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())
|
|
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) "
|
|
"VALUES (%s, %s, %s, %s, %s) RETURNING " + MESSAGE_COLUMNS,
|
|
(uuid4(), chat_id, UUID(actor), data.text, created_at))
|
|
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)
|