"""Read-through кэш сессий в Redis; источник истины -- таблица sessions. Ключ session:, TTL не больше остатка сессии. Заполнение через SET NX, logout записывает отметку отзыва. При недоступном Redis запросы идут в PostgreSQL; потерянная отметка отзыва ведёт к FLUSHDB перед следующим использованием кэша. """ import asyncio import json import time from typing import Awaitable, Callable, Dict, Optional, TypeVar from redis.asyncio import Redis from redis.exceptions import RedisError from .logging_setup import get_logger KEY_PREFIX = "session:" REVOKED = "revoked" CACHE_ERRORS = (RedisError, OSError, asyncio.TimeoutError) T = TypeVar("T") class SessionCache: """Кэш сессий поверх Redis; ошибки Redis не выходят наружу.""" enabled = True def __init__(self, url: str, ttl_cap: int, timeout_ms: int, retry_seconds: int): """Создать клиент Redis с таймаутами; соединение открывается лениво.""" timeout = timeout_ms / 1000 self.client = Redis.from_url( url, socket_timeout=timeout, socket_connect_timeout=timeout, retry_on_timeout=False, decode_responses=True, ) self.ttl_cap = ttl_cap self.timeout = timeout self.retry_seconds = retry_seconds self.down_until = 0.0 self.dirty = False self.stats: Dict[str, int] = { "hits": 0, "misses": 0, "revoked_hits": 0, "errors": 0, "bypassed": 0 } async def _call(self, operation: Callable[[], Awaitable[T]]) -> T: """Выполнить операцию с таймаутом, паузой после сбоя и очисткой грязного кэша.""" if time.monotonic() < self.down_until: self.stats["bypassed"] += 1 raise ConnectionError("cache is paused after a failure") try: if self.dirty: await asyncio.wait_for(self.client.flushdb(), self.timeout * 2) self.dirty = False get_logger().warning("cache: FLUSHDB after a lost revocation") return await asyncio.wait_for(operation(), self.timeout * 2) except CACHE_ERRORS as error: self.stats["errors"] += 1 self.down_until = time.monotonic() + self.retry_seconds get_logger().warning("cache_unavailable type=%s", type(error).__name__) raise async def get(self, token_hash: str) -> Optional[dict]: """Данные пользователя, {"revoked": True} или None при промахе и сбое.""" try: raw = await self._call(lambda: self.client.get(KEY_PREFIX + token_hash)) except CACHE_ERRORS: return None if raw is None: self.stats["misses"] += 1 return None if raw == REVOKED: self.stats["revoked_hits"] += 1 return {"revoked": True} self.stats["hits"] += 1 return json.loads(raw) async def put(self, token_hash: str, user: dict, remaining_seconds: float) -> None: """Сохранить сессию с TTL не больше её остатка, не затирая существующий ключ.""" ttl_ms = int(min(self.ttl_cap, remaining_seconds) * 1000) if ttl_ms <= 0: return payload = json.dumps(user, separators=(",", ":")) try: await self._call( lambda: self.client.set(KEY_PREFIX + token_hash, payload, px=ttl_ms, nx=True) ) except CACHE_ERRORS: pass async def revoke(self, token_hash: str) -> None: """Записать отметку отзыва; при сбое пометить кэш для очистки.""" try: await self._call( lambda: self.client.set( KEY_PREFIX + token_hash, REVOKED, px=self.ttl_cap * 1000 ) ) except CACHE_ERRORS: self.dirty = True async def close(self) -> None: """Закрыть соединения с Redis.""" try: await self.client.aclose() except CACHE_ERRORS: pass class NoCache: """Заглушка при выключенном кэше: всегда промах.""" enabled = False stats: Dict[str, int] = {} async def get(self, token_hash: str) -> Optional[dict]: """Всегда промах.""" return None async def put(self, token_hash: str, user: dict, remaining_seconds: float) -> None: """Ничего не делает.""" return None async def revoke(self, token_hash: str) -> None: """Ничего не делает.""" return None async def close(self) -> None: """Ничего не делает.""" return None def create_cache(settings) -> "SessionCache | NoCache": """SessionCache, если задан CACHE_URL, иначе NoCache.""" if not settings.cache_url: return NoCache() return SessionCache( settings.cache_url, settings.cache_ttl_seconds, settings.cache_timeout_ms, settings.cache_retry_seconds, )