from __future__ import annotations import asyncio import json import logging import time from typing import Dict, Optional, Set, Union import redis.asyncio as redis from redis.exceptions import RedisError from app import config logger = logging.getLogger("messenger.cache") REVOKED = "revoked" class SessionCache: def __init__(self, url: Optional[str]): self._client: Optional[redis.Redis] = None self._down_until = 0.0 self._pending_revokes: Dict[bytes, float] = {} self._retry_tasks: Set[asyncio.Task] = set() if url: pool = redis.BlockingConnectionPool.from_url( url, max_connections=config.CACHE_POOL_MAX, timeout=config.CACHE_TIMEOUT, socket_timeout=config.CACHE_TIMEOUT, socket_connect_timeout=config.CACHE_TIMEOUT, decode_responses=True, ) self._client = redis.Redis(connection_pool=pool) @property def enabled(self) -> bool: return self._client is not None def _usable(self) -> bool: return self._client is not None and time.monotonic() >= self._down_until def _failed(self, op: str, exc: Exception) -> None: self._down_until = time.monotonic() + config.CACHE_RETRY_AFTER logger.warning("cache %s failed (%s); bypassing cache for %.0fs", op, type(exc).__name__, config.CACHE_RETRY_AFTER) @staticmethod def _key(token_hash: bytes) -> str: return "session:" + token_hash.hex() def _revoke_pending(self, token_hash: bytes) -> bool: deadline = self._pending_revokes.get(token_hash) if deadline is None: return False if time.monotonic() >= deadline: self._pending_revokes.pop(token_hash, None) return False return True async def get(self, token_hash: bytes) -> Union[dict, str, None]: if not self._usable() or self._revoke_pending(token_hash): return None try: raw = await self._client.get(self._key(token_hash)) except (RedisError, OSError) as exc: self._failed("get", exc) return None if raw is None or raw == REVOKED: return raw try: return json.loads(raw) except ValueError: return None async def put(self, token_hash: bytes, entry: dict, ttl_seconds: int) -> None: ttl = min(ttl_seconds, config.SESSION_CACHE_MAX_SECONDS) if ttl <= 0 or not self._usable(): return try: await self._client.set(self._key(token_hash), json.dumps(entry), ex=ttl, nx=True) except (RedisError, OSError) as exc: self._failed("set", exc) async def _write_tombstone(self, token_hash: bytes, ttl_seconds: int) -> bool: try: await self._client.set(self._key(token_hash), REVOKED, ex=max(1, min(ttl_seconds, config.SESSION_CACHE_MAX_SECONDS))) return True except (RedisError, OSError) as exc: self._failed("revoke", exc) return False async def revoke(self, token_hash: bytes, ttl_seconds: int) -> bool: if self._client is None: return True if await self._write_tombstone(token_hash, ttl_seconds): return True deadline = time.monotonic() + config.SESSION_CACHE_MAX_SECONDS + 1 self._pending_revokes[token_hash] = deadline task = asyncio.create_task(self._retry_revoke(token_hash, ttl_seconds, deadline)) self._retry_tasks.add(task) task.add_done_callback(self._retry_tasks.discard) return False async def _retry_revoke(self, token_hash: bytes, ttl_seconds: int, deadline: float) -> None: while time.monotonic() < deadline: await asyncio.sleep(1) remaining = int(deadline - time.monotonic()) if remaining > 0 and await self._write_tombstone(token_hash, min(ttl_seconds, remaining)): logger.info("revocation tombstone written after cache recovery") break self._pending_revokes.pop(token_hash, None) async def ping(self) -> bool: if self._client is None: return False try: return bool(await self._client.ping()) except (RedisError, OSError): return False async def close(self) -> None: for task in list(self._retry_tasks): task.cancel() if self._client is not None: await self._client.aclose()