149 lines
5.7 KiB
Python
149 lines
5.7 KiB
Python
"""Read-through кэш сессий в Redis; источник истины -- таблица sessions.
|
||
|
||
Ключ session:<sha256 токена>, TTL не больше остатка сессии. Заполнение
|
||
через SET NX, logout записывает отметку отзыва. При недоступном Redis
|
||
запросы идут в PostgreSQL; потерянная отметка отзыва ведёт к FLUSHDB
|
||
перед следующим использованием кэша в текущем процессе. Положительное
|
||
попадание дополнительно проверяется по sessions в PostgreSQL, поэтому
|
||
потеря локального флага при рестарте не отменяет отзыв.
|
||
"""
|
||
|
||
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,
|
||
)
|