229 lines
14 KiB
Python
229 lines
14 KiB
Python
"""Сессии: вход (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))
|