Files
mtusi2026lab3/src/messenger/sessions.py
T
2026-10-15 00:24:46 +03:00

229 lines
14 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.
"""Сессии: вход (Basic -> токен), проверка Bearer-токена, выход.
Где что хранится:
- ИСТОЧНИК ИСТИНЫ — таблица sessions в PostgreSQL. Она переживает рестарт и решает,
действует ли сессия (не отозвана и не истекла).
- Valkey — КЭШ «hash токена -> пользователь», ОДИН НА ВСЕ РЕПЛИКИ API. Он избавляет от
SQL-запроса на каждом обращении с токеном. Запись, положенную одной репликой, используют
все остальные. Кэш можно в любой момент очистить или потерять: при промахе данные
берутся из PostgreSQL и снова кладутся в кэш.
Политика кэша:
- запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток жизни сессии): кэш никогда
не продлевает сессию, а истёкшая запись к тому же отбрасывается по expires_at;
- logout: сначала отметка revoked_at в PostgreSQL, затем в кэш вместо записи о сессии
кладётся отметка «отозвано» (tombstone). Новая запись о сессии кладётся только если ключа
нет (SET NX), поэтому запрос, который прочитал сессию из базы до logout, не сможет
«воскресить» её в кэше после logout;
- ОБЩЕЕ поколение кэша (с lab3): в Valkey лежит ключ sess:gen, каждая запись о сессии помечена
поколением, в котором её положили. Запись читается одним запросом MGET вместе с текущим
поколением и считается доверенной, только если поколения совпадают. Каждая реплика раз
в CACHE_CHECK_INTERVAL_SECONDS проверяет Valkey (фоновый поток). Реплика, заметившая сбой, перестаёт
пользоваться кэшем, а когда Valkey вернулся, СНАЧАЛА записывает новое случайное поколение
и только потом снова включает кэш. Зачем: пока Valkey был недоступен, logout не мог положить
отметку «отозвано», и в кэше могла остаться старая запись «токен -> пользователь». После смены
поколения её не доверяет ни одна реплика: проверка идёт в PostgreSQL, где сессия отозвана -> 401.
Отметки «отозвано» действуют в любом поколении: они только запрещают, а не разрешают;
- если Valkey недоступен, его обходят: всё работает напрямую через PostgreSQL.
Ожидание подключения (в Docker это ещё и поиск DNS-имени остановленного контейнера,
до нескольких секунд) достаётся фоновому потоку, а не запросам пользователей.
"""
import json
import logging
import secrets
import threading
import time
from dataclasses import asdict, dataclass
from datetime import datetime, timedelta, timezone
import valkey
from . import config, security
from .store import PostgresStore, User, ts
log = logging.getLogger("messenger.sessions")
@dataclass(frozen=True)
class AuthContext:
"""Результат успешной проверки токена: кто пришёл и какой сессией (нужно для logout)."""
user: User
token_hash: bytes
class SessionCache:
PREFIX = "sess:" # пользователю Valkey разрешены только ключи sess:* (ACL: secrets/valkey_users.acl)
GENERATION_KEY = PREFIX + "gen" # общее для всех реплик поколение кэша
NO_GENERATION = "-" # sess:gen ещё не создан (свежий Valkey)
def __init__(self, url: str):
self._client = None
self._down = False # True = кэш считается недоступным, запросы его не трогают
self._lock = threading.Lock()
self._monitor = None
if url:
timeout = config.CACHE_TIMEOUT_MS / 1000
pool = valkey.BlockingConnectionPool.from_url(
url,
max_connections=config.CACHE_POOL_MAX_SIZE, # ограниченный пул соединений
timeout=timeout, # сколько ждать свободное соединение
socket_timeout=timeout, # сколько ждать ответ
socket_connect_timeout=timeout, # сколько ждать подключение
lib_name=None, lib_version=None,
)
self._client = valkey.Valkey(connection_pool=pool)
@property
def enabled(self) -> bool:
return self._client is not None
def _available(self) -> bool:
return self._client is not None and not self._down
def _failed(self, operation: str, exc: Exception) -> None:
with self._lock:
if self._down: # уже знаем о сбое
return
self._down = True
log.warning("Valkey недоступен (%s при %s): работаем напрямую с PostgreSQL",
type(exc).__name__, operation)
# --- фоновая проверка Valkey (один поток на процесс) ---
def start_monitor(self) -> None:
if self._client is None or self._monitor is not None:
return
self._monitor = threading.Thread(target=self._watch, name="valkey-monitor", daemon=True)
self._monitor.start()
def _watch(self) -> None:
while True:
if not self._down:
try:
# Проверка связи и заодно «создать поколение, если его ещё нет» (свежий Valkey).
# NX: существующее поколение не трогаем.
self._client.set(self.GENERATION_KEY, secrets.token_hex(8), nx=True)
except valkey.ValkeyError as exc:
self._failed("heartbeat", exc)
else:
try:
# Valkey вернулся. Сначала НОВОЕ общее поколение: всё, что лежало в кэше до сбоя,
# перестаёт быть доверенным для ВСЕХ реплик. Только потом снова пользуемся кэшем.
self._client.set(self.GENERATION_KEY, secrets.token_hex(8))
with self._lock:
self._down = False
log.info("Valkey снова доступен: новое поколение кэша, записи до сбоя не используются")
except valkey.ValkeyError:
pass
time.sleep(config.CACHE_CHECK_INTERVAL_SECONDS)
# --- операции с кэшем; любая ошибка -> кэш выключается до возвращения Valkey ---
def lookup(self, key: bytes) -> tuple[dict | None, str] | None:
"""(запись или None, текущее поколение) одним запросом MGET. None — кэш недоступен."""
if not self._available():
return None
try:
raw, generation = self._client.mget(self.PREFIX + key.hex(), self.GENERATION_KEY)
except valkey.ValkeyError as exc:
self._failed("mget", exc)
return None
entry = None if raw is None else json.loads(raw)
return entry, (generation.decode() if generation else self.NO_GENERATION)
def generation(self) -> str | None:
"""Текущее поколение (перед созданием сессии). None — кэш недоступен."""
if not self._available():
return None
try:
value = self._client.get(self.GENERATION_KEY)
except valkey.ValkeyError as exc:
self._failed("get", exc)
return None
return value.decode() if value else self.NO_GENERATION
def add(self, key: bytes, value: dict, ttl_ms: int) -> None:
"""Положить запись, только если ключа ещё нет (SET NX): отметку «отозвано» не затираем."""
if not self._available() or ttl_ms < 100:
return
try:
self._client.set(self.PREFIX + key.hex(), json.dumps(value), px=ttl_ms, nx=True)
except valkey.ValkeyError as exc:
self._failed("set", exc)
def mark_revoked(self, key: bytes) -> None:
"""Заменить запись о сессии отметкой «отозвано» на SESSION_CACHE_TTL_SECONDS."""
if not self._available():
return # запись в кэше осталась, но после возвращения Valkey сменится поколение
try:
self._client.set(self.PREFIX + key.hex(), json.dumps({"revoked": True}),
px=config.SESSION_CACHE_TTL_SECONDS * 1000)
except valkey.ValkeyError as exc:
self._failed("set", exc)
def ping(self) -> bool:
try:
return bool(self._client and self._client.ping())
except valkey.ValkeyError:
return False
class Sessions:
def __init__(self, store: PostgresStore, cache: SessionCache, ttl_seconds: int):
self.store = store
self.cache = cache
self.ttl_seconds = ttl_seconds
def login(self, username: str, password: str) -> tuple[str, str, User] | None:
"""Проверяет пароль и создаёт сессию. None — неверные credentials (без уточнений)."""
if not security.PASSWORD_MIN <= len(password) <= security.PASSWORD_MAX:
return None
if not security.USERNAME_RE.fullmatch(username):
return None # такого username не может существовать — в базу даже не ходим
found = self.store.get_credentials(username)
user, password_hash = found if found else (None, None)
# Проверка выполняется и для несуществующего пользователя (с фиктивным hash):
# одинаковое время ответа и одинаковый 401 не раскрывают, есть ли такой username.
if not security.verify_password(password_hash, password) or user is None:
return None
token = security.new_token()
key = security.token_hash(token)
generation = self.cache.generation()
expires_at = self.store.create_session(key, user.id, self.ttl_seconds)
self._remember(key, user, expires_at, generation) # следующий запрос сразу попадёт в кэш
return token, ts(expires_at), user
def authenticate(self, token: str) -> AuthContext | None:
key = security.token_hash(token)
# Поколение читаем ДО обращения к базе (вместе с записью, одним MGET): если во время
# запроса случится сбой Valkey и поколение сменится, наша запись окажется недоверенной.
looked = self.cache.lookup(key)
generation = None
if looked is not None:
cached, generation = looked
if cached is not None:
if cached.get("revoked"):
return None # logout уже был
expires_at = datetime.fromisoformat(cached["expires_at"])
if cached.get("gen") == generation and expires_at > datetime.now(timezone.utc):
return AuthContext(User(**cached["user"]), key)
# запись другого поколения или истёкшая -> проверяем по источнику истины
found = self.store.get_session(key) # промах кэша, недоверенная запись или кэш недоступен
if found is None:
return None
user, expires_at = found
self._remember(key, user, expires_at, generation)
return AuthContext(user, key)
def logout(self, auth: AuthContext) -> None:
self.store.revoke_session(auth.token_hash) # сначала источник истины
self.cache.mark_revoked(auth.token_hash) # затем инвалидация кэша
def _remember(self, key: bytes, user: User, expires_at: datetime, generation: str | None) -> None:
if generation is None:
return # кэш был недоступен, когда мы начинали: ничего не кладём
left = expires_at - datetime.now(timezone.utc)
ttl = min(timedelta(seconds=config.SESSION_CACHE_TTL_SECONDS), left)
self.cache.add(key, {"user": asdict(user), "expires_at": expires_at.isoformat(), "gen": generation},
int(ttl.total_seconds() * 1000))