forked from mtusi2026/mtusi2026lab4
Перенесён минимум lab3. Добавлены загрузка/скачивание PNG/JPEG через API с потоковой проверкой целостности, метаданные в PostgreSQL и байты в приватном bucket, отдельный S3-пользователь с ограниченными правами, идемпотентный bootstrap bucket, компенсация и reconciler (трек 2), тесты отказов, эксперименты по памяти и согласованности.
155 lines
5.2 KiB
Python
155 lines
5.2 KiB
Python
import hashlib
|
|
import json
|
|
import logging
|
|
import secrets
|
|
from datetime import datetime, timedelta, timezone
|
|
from typing import Optional
|
|
|
|
import valkey.asyncio as valkey
|
|
|
|
from app import config, repo
|
|
from app.cursor import fmt
|
|
from app.errors import unavailable
|
|
|
|
log = logging.getLogger("messenger.sessions")
|
|
|
|
REVOKED = "revoked"
|
|
|
|
|
|
class SessionStore:
|
|
def __init__(self, db) -> None:
|
|
self.db = db
|
|
self.client = None
|
|
self.stats = {"hits": 0, "misses": 0, "errors": 0}
|
|
|
|
async def open(self) -> None:
|
|
if not config.CACHE_URL:
|
|
log.info("session cache disabled: CACHE_URL is empty")
|
|
return
|
|
self.client = valkey.Valkey.from_url(
|
|
config.CACHE_URL,
|
|
socket_timeout=config.CACHE_TIMEOUT,
|
|
socket_connect_timeout=config.CACHE_TIMEOUT,
|
|
decode_responses=True,
|
|
)
|
|
|
|
async def close(self) -> None:
|
|
if self.client is not None:
|
|
await self.client.aclose()
|
|
self.client = None
|
|
|
|
@staticmethod
|
|
def digest(token: str) -> bytes:
|
|
return hashlib.sha256(token.encode("utf-8")).digest()
|
|
|
|
@staticmethod
|
|
def key(digest: bytes) -> str:
|
|
return "session:" + digest.hex()
|
|
|
|
async def create(self, user: dict) -> tuple:
|
|
token = secrets.token_urlsafe(32)
|
|
digest = self.digest(token)
|
|
expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
|
|
async with self.db.connection() as conn:
|
|
await conn.execute(
|
|
"INSERT INTO sessions (token_hash, user_id, created_at, expires_at)"
|
|
" VALUES (%s, %s, clock_timestamp(), %s)",
|
|
(digest, user["id"], expires_at),
|
|
)
|
|
await self._cache_put(digest, user, expires_at)
|
|
return token, fmt(expires_at)
|
|
|
|
async def resolve(self, token: str) -> Optional[dict]:
|
|
digest = self.digest(token)
|
|
cached = await self._cache_get(digest)
|
|
if cached == REVOKED:
|
|
self.stats["hits"] += 1
|
|
return None
|
|
if cached is not None:
|
|
self.stats["hits"] += 1
|
|
return cached
|
|
self.stats["misses"] += 1
|
|
async with self.db.connection() as conn:
|
|
cur = await conn.execute(
|
|
"SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at"
|
|
" FROM sessions s JOIN users u ON u.id = s.user_id"
|
|
" WHERE s.token_hash = %s AND s.expires_at > now()",
|
|
(digest,),
|
|
)
|
|
row = await cur.fetchone()
|
|
if row is None:
|
|
return None
|
|
user = repo.public_user(row)
|
|
await self._cache_put(digest, user, row["expires_at"])
|
|
return user
|
|
|
|
async def revoke(self, token: str) -> None:
|
|
digest = self.digest(token)
|
|
await self._cache_revoke(digest)
|
|
try:
|
|
async with self.db.connection() as conn:
|
|
await conn.execute("DELETE FROM sessions WHERE token_hash = %s", (digest,))
|
|
except Exception:
|
|
await self._cache_release(digest)
|
|
raise
|
|
|
|
async def sweep(self) -> int:
|
|
async with self.db.connection() as conn:
|
|
cur = await conn.execute("DELETE FROM sessions WHERE expires_at <= now()")
|
|
return cur.rowcount
|
|
|
|
def _cache_ttl(self, expires_at: datetime) -> int:
|
|
remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds())
|
|
return min(config.SESSION_CACHE_TTL_SECONDS, remaining)
|
|
|
|
async def _cache_get(self, digest: bytes) -> Optional[dict]:
|
|
if self.client is None:
|
|
return None
|
|
try:
|
|
raw = await self.client.get(self.key(digest))
|
|
except Exception:
|
|
self._cache_failed("get")
|
|
return None
|
|
if not raw:
|
|
return None
|
|
if raw == REVOKED:
|
|
return REVOKED
|
|
try:
|
|
return json.loads(raw)
|
|
except ValueError:
|
|
return None
|
|
|
|
async def _cache_put(self, digest: bytes, user: dict, expires_at: datetime) -> None:
|
|
if self.client is None:
|
|
return
|
|
ttl = self._cache_ttl(expires_at)
|
|
if ttl <= 0:
|
|
return
|
|
payload = json.dumps(user)
|
|
try:
|
|
await self.client.set(self.key(digest), payload, ex=ttl, nx=True)
|
|
except Exception:
|
|
self._cache_failed("set")
|
|
|
|
async def _cache_release(self, digest: bytes) -> None:
|
|
if self.client is None:
|
|
return
|
|
try:
|
|
await self.client.delete(self.key(digest))
|
|
except Exception:
|
|
self._cache_failed("release")
|
|
|
|
async def _cache_revoke(self, digest: bytes) -> None:
|
|
if self.client is None:
|
|
return
|
|
try:
|
|
await self.client.set(self.key(digest), REVOKED, ex=config.SESSION_REVOKED_TTL_SECONDS)
|
|
except Exception:
|
|
self._cache_failed("revoke")
|
|
raise unavailable("Кэш сессий недоступен, выход из сессии не подтверждён") from None
|
|
|
|
def _cache_failed(self, operation: str) -> None:
|
|
self.stats["errors"] += 1
|
|
if self.stats["errors"] % 50 == 1:
|
|
log.warning("session cache %s failed, falling back to postgres (errors=%d)", operation, self.stats["errors"])
|