forked from mtusi2026/mtusi2026lab2
91 lines
2.8 KiB
Python
91 lines
2.8 KiB
Python
import hashlib
|
|
import json
|
|
import logging
|
|
import secrets
|
|
from datetime import timedelta
|
|
from uuid import UUID
|
|
|
|
from redis.asyncio import Redis
|
|
from redis.exceptions import RedisError
|
|
|
|
from app.config import Settings
|
|
from app.errors import AppError
|
|
from app.runtime import require_redis, require_settings
|
|
from app.timeutil import format_time, parse_time, utcnow
|
|
|
|
logger = logging.getLogger("app.sessions")
|
|
|
|
|
|
def build_redis(settings: Settings) -> Redis:
|
|
return Redis.from_url(
|
|
settings.cache_url,
|
|
decode_responses=True,
|
|
socket_timeout=settings.redis_socket_timeout_seconds,
|
|
socket_connect_timeout=settings.redis_socket_timeout_seconds,
|
|
health_check_interval=30,
|
|
max_connections=settings.redis_max_connections,
|
|
)
|
|
|
|
|
|
def session_key(token: str) -> str:
|
|
digest = hashlib.sha256(token.encode("utf-8")).hexdigest()
|
|
return "sess:" + digest
|
|
|
|
|
|
async def _call(awaitable):
|
|
try:
|
|
return await awaitable
|
|
except RedisError:
|
|
logger.warning("redis unavailable type=%s", "RedisError")
|
|
raise AppError(503, "unavailable", "Сервис временно недоступен") from None
|
|
|
|
|
|
def _read_payload(raw: str) -> tuple[UUID, object] | None:
|
|
try:
|
|
data = json.loads(raw)
|
|
if not isinstance(data, dict):
|
|
raise ValueError("payload")
|
|
return UUID(str(data["user_id"])), parse_time(data["expires_at"])
|
|
except (ValueError, KeyError, TypeError):
|
|
return None
|
|
|
|
|
|
async def create_session(user_id: UUID) -> tuple[str, object]:
|
|
settings = require_settings()
|
|
token = secrets.token_urlsafe(32)
|
|
expires_at = utcnow() + timedelta(seconds=settings.session_ttl_seconds)
|
|
payload = json.dumps(
|
|
{"user_id": str(user_id), "expires_at": format_time(expires_at)},
|
|
separators=(",", ":"),
|
|
)
|
|
# PXAT — абсолютное время. Повтор AOF после рестарта не продлевает TTL.
|
|
await _call(require_redis().set(session_key(token), payload, pxat=int(expires_at.timestamp() * 1000)))
|
|
return token, expires_at
|
|
|
|
|
|
async def resolve_session(token: str) -> UUID | None:
|
|
key = session_key(token)
|
|
raw = await _call(require_redis().get(key))
|
|
if raw is None:
|
|
return None
|
|
parsed = _read_payload(raw)
|
|
if parsed is None:
|
|
await _call(require_redis().delete(key))
|
|
return None
|
|
user_id, expires_at = parsed
|
|
if expires_at <= utcnow():
|
|
await _call(require_redis().delete(key))
|
|
return None
|
|
return user_id
|
|
|
|
|
|
async def revoke_session(token: str) -> bool:
|
|
raw = await _call(require_redis().getdel(session_key(token)))
|
|
if raw is None:
|
|
return False
|
|
parsed = _read_payload(raw)
|
|
if parsed is None:
|
|
return False
|
|
_, expires_at = parsed
|
|
return expires_at > utcnow()
|