forked from mtusi2026/mtusi2026lab2
349 lines
14 KiB
Python
349 lines
14 KiB
Python
import base64
|
|
import hashlib
|
|
import json
|
|
import logging
|
|
import math
|
|
import os
|
|
import secrets
|
|
from datetime import datetime, timedelta
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Optional, Tuple
|
|
|
|
import redis
|
|
from psycopg.rows import dict_row
|
|
from psycopg_pool import ConnectionPool
|
|
|
|
from .config import (
|
|
DB_LOCK_TIMEOUT_MS,
|
|
DB_POOL_MAX_SIZE,
|
|
DB_POOL_TIMEOUT_SECONDS,
|
|
DB_STATEMENT_TIMEOUT_MS,
|
|
SESSION_TTL_SECONDS,
|
|
)
|
|
from .errors import CacheUnavailableError
|
|
from .security import isoformat, utc_now, valid_uuid, verify_password
|
|
|
|
LOGGER = logging.getLogger("messenger.store")
|
|
|
|
|
|
def database_url() -> str:
|
|
value = os.getenv("DATABASE_URL")
|
|
if value:
|
|
return value
|
|
file_path = os.getenv("DATABASE_URL_FILE")
|
|
if file_path:
|
|
return Path(file_path).read_text(encoding="utf-8").strip()
|
|
raise RuntimeError("Set DATABASE_URL or DATABASE_URL_FILE")
|
|
|
|
|
|
class Store:
|
|
"""PostgreSQL source of truth and optional Redis session lookup cache."""
|
|
|
|
def __init__(self):
|
|
self.pool = ConnectionPool(
|
|
conninfo=database_url(),
|
|
min_size=1,
|
|
max_size=DB_POOL_MAX_SIZE,
|
|
timeout=DB_POOL_TIMEOUT_SECONDS,
|
|
kwargs={
|
|
"row_factory": dict_row,
|
|
"connect_timeout": 5,
|
|
"options": (
|
|
f"-c statement_timeout={DB_STATEMENT_TIMEOUT_MS} "
|
|
f"-c lock_timeout={DB_LOCK_TIMEOUT_MS} "
|
|
"-c idle_in_transaction_session_timeout=10000"
|
|
),
|
|
},
|
|
open=False,
|
|
)
|
|
cache_url = os.getenv("CACHE_URL")
|
|
self.cache = (
|
|
redis.Redis.from_url(
|
|
cache_url,
|
|
decode_responses=True,
|
|
socket_connect_timeout=0.25,
|
|
socket_timeout=0.25,
|
|
retry_on_timeout=False,
|
|
max_connections=16,
|
|
)
|
|
if cache_url
|
|
else None
|
|
)
|
|
|
|
def open(self):
|
|
self.pool.open(wait=True, timeout=10)
|
|
|
|
def close(self):
|
|
if self.cache is not None:
|
|
self.cache.close()
|
|
self.pool.close()
|
|
|
|
def ready(self) -> bool:
|
|
with self.pool.connection(timeout=2) as conn:
|
|
conn.execute("SELECT 1")
|
|
return True
|
|
|
|
def migrate(self):
|
|
migrations = Path(__file__).resolve().parents[1] / "migrations"
|
|
with self.pool.connection() as conn:
|
|
with conn.transaction():
|
|
conn.execute(
|
|
"CREATE TABLE IF NOT EXISTS schema_migrations "
|
|
"(version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())"
|
|
)
|
|
conn.execute("SELECT pg_advisory_xact_lock(2741662026)")
|
|
applied = {row["version"] for row in conn.execute("SELECT version FROM schema_migrations")}
|
|
for migration in sorted(migrations.glob("*.sql")):
|
|
if migration.name in applied:
|
|
continue
|
|
conn.execute(migration.read_text(encoding="utf-8"))
|
|
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (migration.name,))
|
|
|
|
@staticmethod
|
|
def user(row: Dict[str, Any]) -> Dict[str, Any]:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"username": row["username"],
|
|
"display_name": row["display_name"],
|
|
"created_at": isoformat(row["created_at"]),
|
|
}
|
|
|
|
@staticmethod
|
|
def chat(row: Dict[str, Any], member_ids: List[str]) -> Dict[str, Any]:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"title": row["title"],
|
|
"member_ids": member_ids,
|
|
"created_at": isoformat(row["created_at"]),
|
|
}
|
|
|
|
@staticmethod
|
|
def message(row: Dict[str, Any]) -> Dict[str, Any]:
|
|
return {
|
|
"id": str(row["id"]),
|
|
"chat_id": str(row["chat_id"]),
|
|
"sender_id": str(row["sender_id"]),
|
|
"text": row["text"],
|
|
"created_at": isoformat(row["created_at"]),
|
|
}
|
|
|
|
def create_user(self, username: str, display_name: str, password_hash: str) -> Dict[str, Any]:
|
|
with self.pool.connection() as conn:
|
|
with conn.transaction():
|
|
row = conn.execute(
|
|
"INSERT INTO users (username, display_name, password_hash) "
|
|
"VALUES (%s, %s, %s) RETURNING id, username, display_name, created_at",
|
|
(username, display_name, password_hash),
|
|
).fetchone()
|
|
return self.user(row)
|
|
|
|
def get_user(self, user_id: str) -> Optional[Dict[str, Any]]:
|
|
with self.pool.connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
|
(user_id,),
|
|
).fetchone()
|
|
return self.user(row) if row else None
|
|
|
|
def authenticate(self, username: str, password: str) -> Optional[Dict[str, Any]]:
|
|
with self.pool.connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT id, username, display_name, created_at, password_hash "
|
|
"FROM users WHERE username = %s",
|
|
(username,),
|
|
).fetchone()
|
|
if not row or not verify_password(password, row["password_hash"]):
|
|
return None
|
|
return self.user(row)
|
|
|
|
def create_session(self, user_id: str) -> Tuple[str, datetime]:
|
|
token = secrets.token_urlsafe(32)
|
|
expires_at = utc_now() + timedelta(seconds=SESSION_TTL_SECONDS)
|
|
token_hash = hashlib.sha256(token.encode("ascii")).digest()
|
|
with self.pool.connection() as conn:
|
|
conn.execute(
|
|
"INSERT INTO sessions (token_hash, user_id, expires_at) VALUES (%s, %s, %s)",
|
|
(token_hash, user_id, expires_at),
|
|
)
|
|
return token, expires_at
|
|
|
|
@staticmethod
|
|
def _session_lock_key(token_hash: bytes) -> int:
|
|
return int.from_bytes(token_hash[:8], byteorder="big", signed=True)
|
|
|
|
def session_user(self, token: str) -> Optional[Dict[str, Any]]:
|
|
token_hash = hashlib.sha256(token.encode("utf-8")).digest()
|
|
cache_key = "messenger:session:" + token_hash.hex()
|
|
if self.cache is not None:
|
|
try:
|
|
cached = self.cache.get(cache_key)
|
|
if cached:
|
|
return json.loads(cached)
|
|
except (redis.RedisError, ValueError, TypeError):
|
|
LOGGER.warning("session cache read failed; falling back to PostgreSQL")
|
|
with self.pool.connection() as conn:
|
|
with conn.transaction():
|
|
conn.execute("SELECT pg_advisory_xact_lock(%s)", (self._session_lock_key(token_hash),))
|
|
row = conn.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.expires_at > now()",
|
|
(token_hash,),
|
|
).fetchone()
|
|
if not row:
|
|
return None
|
|
user = self.user(row)
|
|
if self.cache is not None:
|
|
ttl_ms = math.floor((row["expires_at"] - utc_now()).total_seconds() * 1000)
|
|
if ttl_ms > 0:
|
|
try:
|
|
self.cache.set(cache_key, json.dumps(user, separators=(",", ":")), px=ttl_ms)
|
|
except redis.RedisError:
|
|
LOGGER.warning("session cache write failed; PostgreSQL remains authoritative")
|
|
return user
|
|
|
|
def revoke_session(self, token: str) -> bool:
|
|
token_hash = hashlib.sha256(token.encode("utf-8")).digest()
|
|
with self.pool.connection() as conn:
|
|
with conn.transaction():
|
|
conn.execute("SELECT pg_advisory_xact_lock(%s)", (self._session_lock_key(token_hash),))
|
|
if self.cache is not None:
|
|
try:
|
|
self.cache.delete("messenger:session:" + token_hash.hex())
|
|
except redis.RedisError as exc:
|
|
raise CacheUnavailableError from exc
|
|
result = conn.execute("DELETE FROM sessions WHERE token_hash = %s", (token_hash,))
|
|
return result.rowcount == 1
|
|
|
|
def create_chat(self, title: str, member_ids: List[str], actor_id: str) -> Dict[str, Any]:
|
|
if actor_id not in member_ids or len(member_ids) != len(set(member_ids)):
|
|
raise ValueError("invalid members")
|
|
with self.pool.connection() as conn:
|
|
with conn.transaction():
|
|
row = conn.execute(
|
|
"INSERT INTO chats (title) VALUES (%s) RETURNING id, title, created_at",
|
|
(title,),
|
|
).fetchone()
|
|
for member_id in member_ids:
|
|
conn.execute(
|
|
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
|
|
(row["id"], member_id),
|
|
)
|
|
return self.chat(row, member_ids)
|
|
|
|
def get_chat(self, chat_id: str, user_id: str) -> Optional[Dict[str, Any]]:
|
|
with self.pool.connection() as conn:
|
|
row = 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, user_id),
|
|
).fetchone()
|
|
if not row:
|
|
return None
|
|
members = conn.execute(
|
|
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY joined_at, user_id",
|
|
(chat_id,),
|
|
).fetchall()
|
|
return self.chat(row, [str(item["user_id"]) for item in members])
|
|
|
|
def list_chats(
|
|
self, user_id: str, limit: int, cursor: Optional[str]
|
|
) -> Tuple[List[Dict[str, Any]], Optional[str]]:
|
|
where = "own.user_id = %s"
|
|
params: List[Any] = [user_id]
|
|
if cursor is not None:
|
|
try:
|
|
raw = base64.b64decode(
|
|
cursor.encode("ascii") + b"=" * (-len(cursor) % 4),
|
|
altchars=b"-_",
|
|
validate=True,
|
|
)
|
|
cursor_user, timestamp, chat_id = raw.decode("utf-8").split("|", 2)
|
|
if cursor_user != user_id or not valid_uuid(chat_id):
|
|
raise ValueError("cursor scope")
|
|
created_at = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
|
|
if created_at.tzinfo is None or created_at.utcoffset() is None:
|
|
raise ValueError("cursor timestamp must include a timezone")
|
|
where += " AND (c.created_at, c.id) > (%s, %s)"
|
|
params.extend((created_at, chat_id))
|
|
except (ValueError, UnicodeError, TypeError) as exc:
|
|
raise ValueError("invalid cursor") from exc
|
|
params.append(limit + 1)
|
|
with self.pool.connection() as conn:
|
|
rows = conn.execute(
|
|
"SELECT c.id, c.title, c.created_at FROM chats c "
|
|
"JOIN chat_members own ON own.chat_id = c.id "
|
|
f"WHERE {where} ORDER BY c.created_at, c.id LIMIT %s",
|
|
params,
|
|
).fetchall()
|
|
has_more = len(rows) > limit
|
|
page = rows[:limit]
|
|
result = []
|
|
for row in page:
|
|
members = conn.execute(
|
|
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY joined_at, user_id",
|
|
(row["id"],),
|
|
).fetchall()
|
|
result.append(self.chat(row, [str(item["user_id"]) for item in members]))
|
|
next_cursor = None
|
|
if has_more and page:
|
|
last = page[-1]
|
|
cursor_data = f"{user_id}|{isoformat(last['created_at'])}|{last['id']}".encode("utf-8")
|
|
next_cursor = base64.urlsafe_b64encode(cursor_data).decode("ascii").rstrip("=")
|
|
return result, next_cursor
|
|
|
|
def create_message(self, chat_id: str, sender_id: str, text: str) -> Optional[Dict[str, Any]]:
|
|
with self.pool.connection() as conn:
|
|
with conn.transaction():
|
|
member = conn.execute(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
|
(chat_id, sender_id),
|
|
).fetchone()
|
|
if not member:
|
|
return None
|
|
row = conn.execute(
|
|
"INSERT INTO messages (chat_id, sender_id, text) "
|
|
"VALUES (%s, %s, %s) RETURNING id, chat_id, sender_id, text, created_at",
|
|
(chat_id, sender_id, text),
|
|
).fetchone()
|
|
return self.message(row)
|
|
|
|
def list_messages(
|
|
self, chat_id: str, user_id: str, limit: int, cursor: Optional[str]
|
|
) -> Optional[Tuple[List[Dict[str, Any]], Optional[str]]]:
|
|
with self.pool.connection() as conn:
|
|
is_member = conn.execute(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
|
(chat_id, user_id),
|
|
).fetchone()
|
|
if not is_member:
|
|
return None
|
|
where = "chat_id = %s"
|
|
params: List[Any] = [chat_id]
|
|
if cursor:
|
|
try:
|
|
raw = base64.urlsafe_b64decode(cursor.encode("ascii") + b"=" * (-len(cursor) % 4))
|
|
decoded_chat, timestamp, message_id = raw.decode("utf-8").split("|", 2)
|
|
if decoded_chat != chat_id or not valid_uuid(message_id):
|
|
raise ValueError("cursor scope")
|
|
created_at = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
|
|
where += " AND (created_at, id) > (%s, %s)"
|
|
params.extend((created_at, message_id))
|
|
except (ValueError, UnicodeError, TypeError) as exc:
|
|
raise ValueError("invalid cursor") from exc
|
|
params.append(limit + 1)
|
|
rows = conn.execute(
|
|
"SELECT id, chat_id, sender_id, text, created_at FROM messages "
|
|
f"WHERE {where} ORDER BY created_at, id LIMIT %s",
|
|
params,
|
|
).fetchall()
|
|
has_more = len(rows) > limit
|
|
page = rows[:limit]
|
|
next_cursor = None
|
|
if has_more and page:
|
|
last = page[-1]
|
|
cursor_data = f"{chat_id}|{isoformat(last['created_at'])}|{last['id']}".encode("utf-8")
|
|
next_cursor = base64.urlsafe_b64encode(cursor_data).decode("ascii").rstrip("=")
|
|
return [self.message(row) for row in page], next_cursor
|