Files
mtusi2026lab4/app/sessions.py
T
RainakandClaude Opus 5.5 2dca5c114b ЛР4 БВТ2304 Запорожец на 3
Вложения: приватный S3-bucket (RustFS 1.0.4) + метаданные в PostgreSQL, upload PNG/JPEG
с лимитами до декодирования, авторизованный download, attachment_ids в сообщениях,
идемпотентный bootstrap bucket, failover/persistence/S3-down тесты и REPORT.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 18:49:12 +03:00

188 lines
8.8 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Сессии: PostgreSQL — источник истины, Valkey — read-through кэш с TTL.
Политика:
- создание: INSERT в PostgreSQL (COMMIT), затем SET в кэш с TTL = min(остаток жизни, SESSION_CACHE_TTL_SECONDS);
- проверка: кэш -> при промахе PostgreSQL -> заполнить кэш;
- logout: UPDATE revoked_at в PostgreSQL (COMMIT), затем DEL из кэша;
- любой сбой Valkey: работаем только с PostgreSQL и SESSION_CACHE_TTL_SECONDS не доверяем кэшу
(все записи, сделанные до сбоя, за это время гарантированно истекут — например, не удалённая
при logout копия отозванной сессии). Flush/рестарт Valkey = пустой кэш, сессии не теряются.
- lab3, несколько реплик: окно недоверия ОБЩЕЕ. Реплика, получившая ошибку Valkey, записывает его
в PostgreSQL (cache_state), а попадание в кэш принимается, только если общий признак проверен
не раньше SHARED_STATE_MAX_AGE назад. Иначе реплика, которая сама сбоя не видела, могла бы
отдать копию сессии, отозванной на другой реплике во время разрыва с Valkey.
"""
import asyncio
import json
import logging
import time
from dataclasses import dataclass
from datetime import datetime, timezone
from uuid import UUID
import redis.asyncio as redis
from redis.exceptions import RedisError
from .config import Settings
from .db import Database
from .security import token_hash
log = logging.getLogger('messenger.sessions')
@dataclass(frozen=True)
class Session:
user_id: UUID
expires_at: datetime
# Насколько устаревшим может быть знание реплики об общем окне недоверия (не чаще 2 запросов/с к БД).
SHARED_STATE_MAX_AGE = 0.5
class SessionCache:
def __init__(self, url: str | None, ttl: int, timeout: float, db: Database):
self.ttl = ttl
self.db = db
self.client = redis.Redis.from_url(
url, socket_timeout=timeout, socket_connect_timeout=timeout,
retry_on_timeout=False, health_check_interval=30,
) if url else None
self._distrust_until = 0.0 # локально (monotonic): своя ошибка действует сразу
self._shared_trusted = False # результат последней проверки общего признака
self._shared_checked = -1e9
self._lock = asyncio.Lock()
@staticmethod
def key(digest: bytes) -> str:
return 'session:' + digest.hex()
def usable(self) -> bool:
return self.client is not None and time.monotonic() >= self._distrust_until
async def trusted(self) -> bool:
"""Можно ли принять попадание в кэш: нет ни своего, ни общего (с других реплик) окна недоверия."""
if not self.usable():
return False
if time.monotonic() - self._shared_checked > SHARED_STATE_MAX_AGE:
async with self._lock:
if time.monotonic() - self._shared_checked > SHARED_STATE_MAX_AGE:
try:
async with self.db.pool.acquire(timeout=1) as conn:
self._shared_trusted = await conn.fetchval(
'SELECT distrust_until <= clock_timestamp() FROM cache_state WHERE id = 1',
timeout=1) is True
except Exception: # без БД сессию всё равно не проверить; кэшу не доверяем
self._shared_trusted = False
self._shared_checked = time.monotonic()
return self._shared_trusted
async def _failed(self, op: str) -> None:
# Не знаем, что успело/не успело записаться: перестаём читать кэш на один максимальный TTL —
# сами сразу и все остальные реплики через общий признак в PostgreSQL.
self._distrust_until = time.monotonic() + self.ttl
self._shared_checked = -1e9
log.warning('valkey %s failed; bypassing cache for %ss on all replicas', op, self.ttl)
try:
async with self.db.pool.acquire(timeout=1) as conn:
await conn.execute(
'UPDATE cache_state SET distrust_until = greatest(distrust_until, '
'clock_timestamp() + make_interval(secs => $1)) WHERE id = 1', self.ttl, timeout=1)
except Exception: # БД недоступна — и кэш, и сессии всё равно проверить нельзя
log.warning('could not publish cache distrust window', exc_info=True)
async def get(self, digest: bytes) -> Session | None:
if not await self.trusted():
return None
try:
raw = await self.client.get(self.key(digest))
except (RedisError, OSError):
await self._failed('get')
return None
if raw is None:
return None
data = json.loads(raw)
return Session(UUID(data['u']), datetime.fromtimestamp(data['e'], timezone.utc))
async def put(self, digest: bytes, session: Session) -> None:
if not self.usable():
return
remaining = int((session.expires_at - datetime.now(timezone.utc)).total_seconds())
ttl = min(self.ttl, remaining)
if ttl <= 0:
return
value = json.dumps({'u': str(session.user_id), 'e': session.expires_at.timestamp()})
try:
await self.client.set(self.key(digest), value, ex=ttl)
except (RedisError, OSError):
await self._failed('set')
async def delete(self, digest: bytes) -> None:
if self.client is None:
return
try:
await self.client.delete(self.key(digest))
except (RedisError, OSError):
await self._failed('delete')
async def close(self) -> None:
if self.client is not None:
await self.client.aclose()
class SessionStore:
def __init__(self, settings: Settings, db: Database):
self.ttl = settings.session_ttl
self.db = db
self.cache = SessionCache(settings.cache_url, settings.session_cache_ttl, settings.cache_timeout, db)
async def create(self, user_id: UUID, token: str) -> Session:
digest = token_hash(token)
async with self.db.connection() as conn:
# Время берём из БД, чтобы срок не зависел от часов конкретной реплики API.
expires_at = await conn.fetchval(
'INSERT INTO sessions (token_hash, user_id, expires_at) '
'VALUES ($1, $2, clock_timestamp() + make_interval(secs => $3)) RETURNING expires_at',
digest, user_id, self.ttl,
)
session = Session(user_id, expires_at)
await self.cache.put(digest, session)
return session
async def resolve(self, token: str) -> Session | None:
digest = token_hash(token)
now = datetime.now(timezone.utc)
cached = await self.cache.get(digest)
if cached is not None and cached.expires_at > now:
return cached
async with self.db.connection() as conn:
row = await conn.fetchrow(
'SELECT user_id, expires_at FROM sessions '
'WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > clock_timestamp()',
digest,
)
if row is None:
return None
session = Session(row['user_id'], row['expires_at'])
await self.cache.put(digest, session)
return session
async def revoke(self, token: str) -> bool:
digest = token_hash(token)
async with self.db.connection() as conn:
status = await conn.execute(
'UPDATE sessions SET revoked_at = clock_timestamp() '
'WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > clock_timestamp()',
digest,
)
# Инвалидация кэша строго после COMMIT в источнике истины.
await self.cache.delete(digest)
return status == 'UPDATE 1'
async def purge_expired(self) -> int:
async with self.db.connection() as conn:
status = await conn.execute(
"DELETE FROM sessions WHERE expires_at < clock_timestamp() - interval '1 day'")
return int(status.split()[-1])