Files
mtusi2026lab2/src/store.py
T

266 lines
13 KiB
Python

"""PostgreSQL is authoritative; Valkey caches only immutable public profiles."""
from contextlib import contextmanager
import base64
import datetime as dt
import hashlib
import hmac
import json
import logging
import os
import re
import secrets
import uuid
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool, PoolTimeout, TooManyRequests
import redis
from redis.backoff import NoBackoff
from redis.retry import Retry
from config import integer, secret
from http_transport import APIError, fields, identifier, invalid, text
LOG = logging.getLogger('messenger')
USER_COLUMNS = 'id,username,display_name,created_at'
CHAT_COLUMNS = 'c.id,c.title,c.created_at,ARRAY(SELECT user_id FROM chat_members WHERE chat_id=c.id ORDER BY user_id) AS member_ids'
def public(row):
result = {}
for key, value in row.items():
if isinstance(value, uuid.UUID):
value = str(value)
elif isinstance(value, dt.datetime):
value = value.astimezone(dt.timezone.utc).isoformat(timespec='microseconds').replace('+00:00','Z')
elif isinstance(value, list):
value = [str(item) for item in value]
result[key] = value
return result
def password_hash(password, salt=None):
salt = salt if salt is not None else secrets.token_bytes(16)
derived = hashlib.scrypt(password.encode('utf-8'), salt=salt, n=16384, r=8, p=1, dklen=32, maxmem=64*1024*1024)
return 'scrypt$16384$8$1$' + salt.hex() + '$' + derived.hex()
def password_valid(password, encoded):
parts = encoded.split('$')
return hmac.compare_digest(password_hash(password, bytes.fromhex(parts[4])), encoded)
def unauthorized(basic=False):
challenge = 'Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"'
return APIError(401, 'unauthorized', 'Неверные или отсутствующие учётные данные', {'WWW-Authenticate': challenge})
class Store:
def __init__(self):
if os.environ.get('SESSION_STORE','postgres') != 'postgres':
raise ValueError('SESSION_STORE must be postgres')
self.ttl = integer('SESSION_TTL_SECONDS', 3600)
self.cache_ttl = integer('PROFILE_CACHE_TTL_SECONDS', 300)
self.pool = ConnectionPool(secret('DATABASE_URL'), min_size=1,
max_size=integer('DB_POOL_MAX', 8, maximum=32),
max_waiting=32, timeout=2, reconnect_timeout=3,
check=ConnectionPool.check_connection,
kwargs={'connect_timeout': 2, 'row_factory': dict_row,
'options': '-c statement_timeout=2000 -c lock_timeout=1000 -c idle_in_transaction_session_timeout=5000'},
open=True)
self.cache = redis.Redis.from_url(secret('CACHE_URL'), decode_responses=True,
socket_connect_timeout=.2, socket_timeout=.2,
max_connections=16, retry=Retry(NoBackoff(), 0))
with self.connection() as connection:
self.cursor_key = bytes.fromhex(connection.execute("SELECT value FROM app_settings WHERE name='cursor_key'").fetchone()['value'])
self.dummy_hash = password_hash('not-an-existing-password')
@contextmanager
def connection(self):
try:
with self.pool.connection() as connection:
yield connection
except (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout, TooManyRequests,
psycopg.errors.QueryCanceled, psycopg.errors.LockNotAvailable):
raise APIError(503, 'unavailable', 'Хранилище временно недоступно') from None
def close(self):
self.pool.close()
self.cache.close()
def ready(self):
with self.connection() as connection:
connection.execute('SELECT 1')
def user(self, body):
fields(body, ('username','display_name','password'))
name = body['username']
if not isinstance(name, str) or not re.fullmatch(r'[a-z0-9_]{3,32}', name):
raise invalid('Неверный username')
display = text(body['display_name'], 100)
password = text(body['password'], 128)
if len(password) < 12:
raise invalid('Пароль должен содержать 12–128 символов')
encoded = password_hash(password)
try:
with self.connection() as connection:
user = connection.execute('INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING ' + USER_COLUMNS,
(uuid.uuid4(),name,display,encoded)).fetchone()
return public(user)
except psycopg.errors.UniqueViolation:
raise APIError(409, 'conflict', 'Username занят') from None
def profile(self, actor):
key = 'profile:v1:' + actor
try:
value = self.cache.get(key)
if value is not None:
result = json.loads(value)
if set(result) == {'id','username','display_name','created_at'} and result['id'] == actor:
return result
except (redis.RedisError, ValueError, TypeError):
LOG.info('profile_cache_fallback')
with self.connection() as connection:
result = public(connection.execute('SELECT ' + USER_COLUMNS + ' FROM users WHERE id=%s', (actor,)).fetchone())
try:
self.cache.setex(key, self.cache_ttl, json.dumps(result))
except redis.RedisError:
LOG.info('profile_cache_write_skipped')
return result
def login(self, authorization):
try:
scheme, value = authorization.split(' ', 1)
if scheme.lower() != 'basic':
raise ValueError
decoded = base64.b64decode(value, validate=True).decode('utf-8')
username, separator, password = decoded.partition(':')
if not separator or not re.fullmatch(r'[a-z0-9_]{3,32}',username) or not 12 <= len(password) <= 128:
raise ValueError
password.encode('utf-8')
except (ValueError, AttributeError, UnicodeError):
raise unauthorized(True) from None
with self.connection() as connection:
user = connection.execute('SELECT id,password_hash FROM users WHERE username=%s', (username,)).fetchone()
valid = password_valid(password, user['password_hash'] if user else self.dummy_hash)
if not valid or user is None:
raise unauthorized(True)
token = secrets.token_urlsafe(32)
with self.connection() as connection:
session = connection.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at",
(hashlib.sha256(token.encode()).digest(),user['id'],self.ttl)).fetchone()
return {'token': token, 'token_type': 'Bearer', 'expires_at': public(session)['expires_at'], 'user': self.profile(str(user['id']))}
@staticmethod
def token_hash(authorization):
try:
scheme, token = authorization.split(' ', 1)
if scheme.lower() != 'bearer' or not re.fullmatch(r'[A-Za-z0-9_-]{43}', token):
raise ValueError
return hashlib.sha256(token.encode()).digest()
except (ValueError, AttributeError):
raise unauthorized() from None
def authenticate(self, authorization):
digest = self.token_hash(authorization)
with self.connection() as connection:
session = connection.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()', (digest,)).fetchone()
if session is None:
raise unauthorized()
return str(session['user_id'])
def logout(self, authorization):
digest = self.token_hash(authorization)
with self.connection() as connection:
revoked = connection.execute('DELETE FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp() RETURNING user_id', (digest,)).fetchone()
if revoked is None:
raise unauthorized()
def chat(self, actor, body):
fields(body, ('title','member_ids'))
title = text(body['title'],100)
members = body['member_ids']
if not isinstance(members,list) or not 1 <= len(members) <= 100:
raise invalid('Ожидался список участников длиной 1–100')
members = [identifier(member) for member in members]
if actor not in members or len(set(members)) != len(members):
raise invalid('Неверный список участников')
cid = uuid.uuid4()
try:
with self.connection() as connection:
# Deliberately rely on FK inside the SAME transaction: any bad
# member rolls back the chat and all earlier memberships.
connection.execute('INSERT INTO chats(id,title) VALUES (%s,%s)', (cid,title))
with connection.cursor() as cursor:
cursor.executemany('INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)', [(cid,member) for member in members])
return public(connection.execute('SELECT ' + CHAT_COLUMNS + ' FROM chats c WHERE c.id=%s', (cid,)).fetchone())
except psycopg.errors.ForeignKeyViolation:
raise invalid('Неверный список участников') from None
def accessible(self, actor, cid, connection=None):
cid = identifier(cid)
if connection is None:
with self.connection() as connection:
return self.accessible(actor,cid,connection)
chat = connection.execute('SELECT ' + CHAT_COLUMNS + ' FROM chats c WHERE c.id=%s AND EXISTS (SELECT 1 FROM chat_members WHERE chat_id=c.id AND user_id=%s)', (cid,actor)).fetchone()
if chat is None:
raise APIError(404, 'not_found', 'Объект не найден')
return public(chat)
def message(self, actor, cid, body):
fields(body, ('text',))
value = text(body['text'],4000)
with self.connection() as connection:
self.accessible(actor,cid,connection)
timestamp = connection.execute("UPDATE chats SET last_message_at=greatest(clock_timestamp(),last_message_at + interval '1 microsecond') WHERE id=%s RETURNING last_message_at", (cid,)).fetchone()['last_message_at']
result = connection.execute('INSERT INTO messages(id,chat_id,sender_id,text,created_at) VALUES (%s,%s,%s,%s,%s) RETURNING id,chat_id,sender_id,text,created_at', (uuid.uuid4(),cid,actor,value,timestamp)).fetchone()
return public(result)
def encode_cursor(self, scope, row):
raw = json.dumps([scope,row['created_at'],row['id']], separators=(',',':')).encode()
return base64.urlsafe_b64encode(raw + hmac.digest(self.cursor_key, raw, 'sha256')).decode().rstrip('=')
def decode_cursor(self, scope, cursor):
try:
if not cursor or len(cursor) > 2048:
raise ValueError
data = base64.b64decode(cursor + '=' * (-len(cursor) % 4), altchars=b'-_',validate=True)
raw, signature = data[:-32], data[-32:]
if not hmac.compare_digest(hmac.digest(self.cursor_key,raw,'sha256'),signature):
raise ValueError
resource, timestamp, uid = json.loads(raw)
if resource != scope or not isinstance(timestamp,str):
raise ValueError
return dt.datetime.fromisoformat(timestamp.replace('Z','+00:00')), identifier(uid)
except (ValueError, TypeError, UnicodeError, APIError):
raise invalid('Неверный cursor для данного ресурса') from None
def history(self, actor, cid, limit, cursor):
scope = 'messages:' + identifier(cid)
after = self.decode_cursor(scope,cursor) if cursor is not None else None
with self.connection() as connection:
self.accessible(actor,cid,connection)
query = 'SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s'
values = [cid]
if after:
query += ' AND (created_at,id) > (%s,%s)'
values.extend(after)
query += ' ORDER BY created_at,id LIMIT %s'
rows = connection.execute(query, (*values,limit+1)).fetchall()
items = [public(row) for row in rows[:limit]]
return {'items':items, 'next_cursor':self.encode_cursor(scope,items[-1]) if len(rows)>limit else None}
def list_chats(self, actor, limit, cursor):
scope = 'chats:' + actor
after = self.decode_cursor(scope,cursor) if cursor is not None else None
query = 'SELECT ' + CHAT_COLUMNS + ' FROM chats c JOIN chat_members mine ON mine.chat_id=c.id WHERE mine.user_id=%s'
values = [actor]
if after:
query += ' AND (c.created_at,c.id) > (%s,%s)'
values.extend(after)
query += ' ORDER BY c.created_at,c.id LIMIT %s'
with self.connection() as connection:
rows = connection.execute(query, (*values,limit+1)).fetchall()
items = [public(row) for row in rows[:limit]]
return {'items':items, 'next_cursor':self.encode_cursor(scope,items[-1]) if len(rows)>limit else None}