fix(api): security, caching, atomic rate limits, url obfuscation
Redis:
- Singleton ConnectionPool (redis.asyncio), 50 connections — не создаём
новое TCP-соединение на каждый HTTP-запрос
Rate limiter:
- Полностью переписан на async/await
- Lua-скрипт _LUA_CHECK_AND_INCR — атомарная проверка+инкремент без race condition
- Lua-скрипт _LUA_ACQUIRE_CONCURRENT — атомарный захват слота задачи
- Старый паттерн INCR→check→DECR удалён (race condition при конкурентных запросах)
Security:
- get_current_user кэширует пользователя в Redis на 5 минут (TTL)
Раньше: SELECT users на каждый HTTP-запрос
Теперь: Redis GET (кэш) → SELECT users (только при промахе)
- hashed_password НЕ кладётся в кэш
- invalidate_user_cache() для сброса при смене тарифа/пароля
- get_ws_user() для WebSocket через ?token=JWT (браузеры не могут
передавать Authorization header при WS-handshake)
WebSocket:
- Добавлена аутентификация (Depends(get_ws_user))
- Проверка ownership задачи ДО accept() соединения
- Чужой task_id → закрытие с кодом 4004
URL obfuscation:
- Task.public_id = secrets.token_urlsafe(16) = 22 случайных base64url символа
- Клиент работает только с public_id, внутренний UUID не раскрывается
- Все роутеры переключены на public_id в WHERE условиях
- TaskResponse больше не возвращает input_data (там minio_key и т.д.)
- Миграция 002_add_task_public_id.py
MinIO:
- Singleton клиент (не создаём новый на каждый upload)
- ensure_bucket() вызывается один раз при старте (lifespan), не на каждый запрос
- Путь uploads/{doc_uuid}{ext} — user_id убран из пути
CORS:
- Убраны wildcard allow_methods/allow_headers (несовместимы с credentials=True)
- Явный список: methods=[GET,POST,DELETE,OPTIONS], headers=[Authorization,Content-Type,Accept]
- Swagger/OpenAPI доступны только в ENVIRONMENT=development
Documents:
- Content-Length проверяется ДО чтения тела (ранняя отбивка больших файлов)
- Повторная проверка реального размера после чтения (защита от поддельного заголовка)
- Используем get_current_verified_user вместо get_current_user (требуем подтверждённый email)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
jze9
48
services/api/app/core/minio_client.py
Normal file
48
services/api/app/core/minio_client.py
Normal file
@@ -0,0 +1,48 @@
|
||||
"""Singleton MinIO клиент.
|
||||
|
||||
MinIO SDK держит пул HTTP-соединений внутри себя — создаём один экземпляр
|
||||
на весь процесс. Бакеты проверяем один раз при старте приложения.
|
||||
"""
|
||||
|
||||
import logging
|
||||
|
||||
from minio import Minio
|
||||
from minio.error import S3Error
|
||||
|
||||
from app.config import settings
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
_client: Minio | None = None
|
||||
_initialized_buckets: set[str] = set()
|
||||
|
||||
|
||||
def get_minio() -> Minio:
|
||||
"""Вернуть singleton MinIO клиент."""
|
||||
global _client
|
||||
if _client is None:
|
||||
_client = Minio(
|
||||
settings.MINIO_ENDPOINT,
|
||||
access_key=settings.MINIO_ACCESS_KEY,
|
||||
secret_key=settings.MINIO_SECRET_KEY,
|
||||
secure=settings.MINIO_SECURE,
|
||||
)
|
||||
return _client
|
||||
|
||||
|
||||
def ensure_bucket(bucket: str) -> None:
|
||||
"""Создать бакет если не существует. Вызывается один раз при старте."""
|
||||
if bucket in _initialized_buckets:
|
||||
return
|
||||
|
||||
client = get_minio()
|
||||
try:
|
||||
if not client.bucket_exists(bucket):
|
||||
client.make_bucket(bucket)
|
||||
logger.info(f"MinIO: бакет '{bucket}' создан")
|
||||
else:
|
||||
logger.info(f"MinIO: бакет '{bucket}' существует")
|
||||
_initialized_buckets.add(bucket)
|
||||
except S3Error as e:
|
||||
logger.error(f"MinIO: ошибка проверки бакета '{bucket}': {e}")
|
||||
raise
|
||||
@@ -1,13 +1,22 @@
|
||||
"""Redis-based rate limiter для проверки лимитов по тарифному плану."""
|
||||
"""Redis-based rate limiter с атомарными Lua-скриптами.
|
||||
|
||||
import json
|
||||
Проблема наивного подхода (GET → проверка → INCR):
|
||||
- Race condition: 10 конкурентных запросов могут одновременно пройти GET,
|
||||
увидеть значение ниже лимита и все инкрементировать.
|
||||
|
||||
Решение: один Lua-скрипт выполняется атомарно на стороне Redis.
|
||||
Redis гарантирует, что между командами внутри скрипта нет других операций.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from datetime import datetime, timezone
|
||||
|
||||
import redis
|
||||
from app.core.redis_client import get_redis
|
||||
|
||||
from app.config import settings
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# ─── Лимиты по тарифам ────────────────────────────────────────────────────────
|
||||
|
||||
# Лимиты по тарифным планам
|
||||
PLAN_LIMITS: dict[str, dict[str, int | None]] = {
|
||||
"free": {
|
||||
"search_per_day": 10,
|
||||
@@ -16,7 +25,7 @@ PLAN_LIMITS: dict[str, dict[str, int | None]] = {
|
||||
"concurrent": 1,
|
||||
},
|
||||
"student": {
|
||||
"search_per_day": None, # None = безлимит
|
||||
"search_per_day": None, # None = безлимит
|
||||
"summarize_per_month": 30,
|
||||
"plagiarism_per_month": 10,
|
||||
"concurrent": 2,
|
||||
@@ -35,133 +44,125 @@ PLAN_LIMITS: dict[str, dict[str, int | None]] = {
|
||||
},
|
||||
}
|
||||
|
||||
# Маппинг действий на ключи лимитов
|
||||
ACTION_TO_LIMIT: dict[str, tuple[str, str]] = {
|
||||
"search": ("search_per_day", "day"),
|
||||
"summarize": ("summarize_per_month", "month"),
|
||||
"plagiarism": ("plagiarism_per_month", "month"),
|
||||
"gost": ("gost_per_month", "month"), # ГОСТ всегда разрешён
|
||||
"search": ("search_per_day", "day"),
|
||||
"summarize": ("summarize_per_month", "month"),
|
||||
"plagiarism":("plagiarism_per_month", "month"),
|
||||
# gost не ограничен — не в маппинге
|
||||
}
|
||||
|
||||
# ─── Lua-скрипты ──────────────────────────────────────────────────────────────
|
||||
|
||||
def get_redis_client() -> redis.Redis:
|
||||
"""Создать синхронный Redis клиент."""
|
||||
return redis.from_url(settings.REDIS_URL, decode_responses=True)
|
||||
# Атомарная проверка + инкремент лимита.
|
||||
# Возвращает [current_value, allowed] где allowed = 1 если OK, 0 если превышен.
|
||||
_LUA_CHECK_AND_INCR = """
|
||||
local key = KEYS[1]
|
||||
local limit = tonumber(ARGV[1])
|
||||
local ttl = tonumber(ARGV[2])
|
||||
|
||||
local current = tonumber(redis.call('GET', key) or '0')
|
||||
|
||||
if current >= limit then
|
||||
return {current, 0}
|
||||
end
|
||||
|
||||
local new_val = redis.call('INCR', key)
|
||||
-- Устанавливаем TTL только при первом инкременте (когда ключ только что создан)
|
||||
if new_val == 1 then
|
||||
redis.call('EXPIRE', key, ttl)
|
||||
end
|
||||
return {new_val, 1}
|
||||
"""
|
||||
|
||||
# Атомарная проверка + инкремент счётчика одновременных задач.
|
||||
# Возвращает 1 если слот получен, 0 если превышен лимит.
|
||||
_LUA_ACQUIRE_CONCURRENT = """
|
||||
local key = KEYS[1]
|
||||
local limit = tonumber(ARGV[1])
|
||||
local ttl = tonumber(ARGV[2])
|
||||
|
||||
local current = tonumber(redis.call('GET', key) or '0')
|
||||
if current >= limit then
|
||||
return 0
|
||||
end
|
||||
|
||||
redis.call('INCR', key)
|
||||
redis.call('EXPIRE', key, ttl)
|
||||
return 1
|
||||
"""
|
||||
|
||||
|
||||
def _get_period_key(period: str) -> str:
|
||||
"""Получить строку периода для Redis ключа."""
|
||||
def _period_suffix(period: str) -> str:
|
||||
now = datetime.now(timezone.utc)
|
||||
if period == "day":
|
||||
return now.strftime("%Y-%m-%d")
|
||||
elif period == "month":
|
||||
return now.strftime("%Y-%m")
|
||||
return now.strftime("%Y-%m-%d")
|
||||
return now.strftime("%Y-%m-%d") if period == "day" else now.strftime("%Y-%m")
|
||||
|
||||
|
||||
def check_and_increment_limit(user_id: int, action: str, plan: str) -> dict:
|
||||
async def check_and_increment_limit(
|
||||
user_id: int,
|
||||
action: str,
|
||||
plan: str,
|
||||
) -> dict:
|
||||
"""
|
||||
Проверить лимит и инкрементировать счётчик.
|
||||
|
||||
Args:
|
||||
user_id: ID пользователя
|
||||
action: Действие (search, plagiarism, summarize, gost)
|
||||
plan: Тарифный план пользователя
|
||||
Атомарно проверить лимит и инкрементировать счётчик.
|
||||
|
||||
Returns:
|
||||
dict с полями:
|
||||
- allowed: bool — разрешено ли действие
|
||||
- current: int — текущее количество использований
|
||||
- limit: int | None — лимит (None = безлимит)
|
||||
- remaining: int | None — осталось использований
|
||||
- reset_at: str — когда сбрасывается счётчик
|
||||
{allowed, current, limit, remaining, reset_at}
|
||||
"""
|
||||
limits = PLAN_LIMITS.get(plan, PLAN_LIMITS["free"])
|
||||
|
||||
if action not in ACTION_TO_LIMIT:
|
||||
# Неизвестное действие — разрешаем
|
||||
return {"allowed": True, "current": 0, "limit": None, "remaining": None}
|
||||
|
||||
limit_key, period = ACTION_TO_LIMIT[action]
|
||||
limit_value = limits.get(limit_key)
|
||||
|
||||
# Безлимитный план
|
||||
if limit_value is None:
|
||||
return {
|
||||
"allowed": True,
|
||||
"current": 0,
|
||||
"limit": None,
|
||||
"remaining": None,
|
||||
"reset_at": None,
|
||||
}
|
||||
if limit_value is None: # безлимит
|
||||
return {"allowed": True, "current": 0, "limit": None, "remaining": None}
|
||||
|
||||
period_str = _get_period_key(period)
|
||||
redis_key = f"rate:{user_id}:{action}:{period_str}"
|
||||
period_str = _period_suffix(period)
|
||||
redis_key = f"rl:{user_id}:{action}:{period_str}"
|
||||
ttl = 86_400 if period == "day" else 86_400 * 32
|
||||
|
||||
r = get_redis_client()
|
||||
|
||||
# Атомарно инкрементировать
|
||||
pipe = r.pipeline()
|
||||
pipe.incr(redis_key)
|
||||
# Устанавливаем TTL: для дня — 86400 сек, для месяца — 32 дня
|
||||
ttl = 86400 if period == "day" else 86400 * 32
|
||||
pipe.expire(redis_key, ttl)
|
||||
results = pipe.execute()
|
||||
|
||||
current = results[0]
|
||||
|
||||
if current > limit_value:
|
||||
# Декрементировать обратно (не считать запрещённые)
|
||||
r.decr(redis_key)
|
||||
current -= 1
|
||||
return {
|
||||
"allowed": False,
|
||||
"current": current,
|
||||
"limit": limit_value,
|
||||
"remaining": 0,
|
||||
"reset_at": period_str,
|
||||
}
|
||||
r = get_redis()
|
||||
result = await r.eval(_LUA_CHECK_AND_INCR, 1, redis_key, limit_value, ttl)
|
||||
current, allowed = int(result[0]), bool(result[1])
|
||||
|
||||
return {
|
||||
"allowed": True,
|
||||
"allowed": allowed,
|
||||
"current": current,
|
||||
"limit": limit_value,
|
||||
"remaining": limit_value - current,
|
||||
"remaining": max(0, limit_value - current) if allowed else 0,
|
||||
"reset_at": period_str,
|
||||
}
|
||||
|
||||
|
||||
def check_concurrent_limit(user_id: int, plan: str) -> bool:
|
||||
async def acquire_concurrent_slot(user_id: int, plan: str) -> bool:
|
||||
"""
|
||||
Проверить лимит одновременных задач.
|
||||
Атомарно захватить слот одновременной задачи.
|
||||
|
||||
Returns:
|
||||
True если можно создать новую задачу, False если превышен лимит.
|
||||
True — слот получен (задачу можно создавать).
|
||||
False — все слоты заняты.
|
||||
"""
|
||||
limits = PLAN_LIMITS.get(plan, PLAN_LIMITS["free"])
|
||||
max_concurrent = limits.get("concurrent", 1)
|
||||
|
||||
r = get_redis_client()
|
||||
r = get_redis()
|
||||
result = await r.eval(
|
||||
_LUA_ACQUIRE_CONCURRENT,
|
||||
1,
|
||||
f"concurrent:{user_id}",
|
||||
max_concurrent,
|
||||
3_600, # TTL 1 час — автосброс если воркер упал не освободив слот
|
||||
)
|
||||
return bool(result)
|
||||
|
||||
|
||||
async def release_concurrent_slot(user_id: int) -> None:
|
||||
"""Освободить слот одновременной задачи после завершения."""
|
||||
r = get_redis()
|
||||
key = f"concurrent:{user_id}"
|
||||
current = r.get(key)
|
||||
|
||||
return (current is None) or (int(current) < max_concurrent)
|
||||
|
||||
|
||||
def increment_concurrent(user_id: int) -> None:
|
||||
"""Увеличить счётчик одновременных задач (при создании задачи)."""
|
||||
r = get_redis_client()
|
||||
key = f"concurrent:{user_id}"
|
||||
pipe = r.pipeline()
|
||||
pipe.incr(key)
|
||||
pipe.expire(key, 3600) # Автосброс через 1 час
|
||||
pipe.execute()
|
||||
|
||||
|
||||
def decrement_concurrent(user_id: int) -> None:
|
||||
"""Уменьшить счётчик одновременных задач (при завершении задачи)."""
|
||||
r = get_redis_client()
|
||||
key = f"concurrent:{user_id}"
|
||||
current = r.get(key)
|
||||
# DECR безопасен: Redis не уходит в отрицательные значения если мы контролируем acquire
|
||||
current = await r.get(key)
|
||||
if current and int(current) > 0:
|
||||
r.decr(key)
|
||||
await r.decr(key)
|
||||
|
||||
36
services/api/app/core/redis_client.py
Normal file
36
services/api/app/core/redis_client.py
Normal file
@@ -0,0 +1,36 @@
|
||||
"""Singleton пул Redis-соединений.
|
||||
|
||||
Один ConnectionPool на весь процесс — не создаём новое соединение на каждый запрос.
|
||||
Используем redis.asyncio для совместимости с FastAPI async endpoints.
|
||||
"""
|
||||
|
||||
import redis.asyncio as aioredis
|
||||
|
||||
from app.config import settings
|
||||
|
||||
_pool: aioredis.ConnectionPool | None = None
|
||||
|
||||
|
||||
def get_pool() -> aioredis.ConnectionPool:
|
||||
"""Инициализировать пул при первом вызове, затем возвращать тот же."""
|
||||
global _pool
|
||||
if _pool is None:
|
||||
_pool = aioredis.ConnectionPool.from_url(
|
||||
settings.REDIS_URL,
|
||||
max_connections=50,
|
||||
decode_responses=True,
|
||||
)
|
||||
return _pool
|
||||
|
||||
|
||||
def get_redis() -> aioredis.Redis:
|
||||
"""Получить Redis клиент из пула (не создаёт новое TCP-соединение)."""
|
||||
return aioredis.Redis(connection_pool=get_pool())
|
||||
|
||||
|
||||
async def close_pool() -> None:
|
||||
"""Закрыть пул при остановке приложения."""
|
||||
global _pool
|
||||
if _pool:
|
||||
await _pool.aclose()
|
||||
_pool = None
|
||||
@@ -1,9 +1,11 @@
|
||||
"""Утилиты безопасности: JWT, хэширование паролей, dependency для получения текущего пользователя."""
|
||||
"""JWT, хэширование паролей, dependency получения пользователя с кэшированием."""
|
||||
|
||||
import json
|
||||
import logging
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from typing import Any
|
||||
|
||||
from fastapi import Depends, HTTPException, status
|
||||
from fastapi import Depends, HTTPException, Query, WebSocket, status
|
||||
from fastapi.security import OAuth2PasswordBearer
|
||||
from jose import JWTError, jwt
|
||||
from passlib.context import CryptContext
|
||||
@@ -11,53 +13,47 @@ from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.config import settings
|
||||
from app.core.redis_client import get_redis
|
||||
from app.database import get_db
|
||||
|
||||
# Контекст хэширования паролей (bcrypt)
|
||||
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# OAuth2 схема
|
||||
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
|
||||
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
|
||||
|
||||
# TTL кэша пользователя в Redis (5 минут)
|
||||
_USER_CACHE_TTL = 300
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
"""Хэшировать пароль через bcrypt."""
|
||||
return pwd_context.hash(password)
|
||||
|
||||
|
||||
def verify_password(plain_password: str, hashed_password: str) -> bool:
|
||||
"""Проверить соответствие пароля его хэшу."""
|
||||
return pwd_context.verify(plain_password, hashed_password)
|
||||
def verify_password(plain: str, hashed: str) -> bool:
|
||||
return pwd_context.verify(plain, hashed)
|
||||
|
||||
|
||||
def create_access_token(data: dict[str, Any], expires_delta: timedelta | None = None) -> str:
|
||||
"""Создать JWT токен доступа."""
|
||||
to_encode = data.copy()
|
||||
payload = data.copy()
|
||||
expire = datetime.now(timezone.utc) + (
|
||||
expires_delta or timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
|
||||
)
|
||||
to_encode.update({"exp": expire})
|
||||
return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
|
||||
payload["exp"] = expire
|
||||
return jwt.encode(payload, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
|
||||
|
||||
|
||||
def verify_token(token: str) -> dict[str, Any]:
|
||||
def _decode_token(token: str) -> int:
|
||||
"""
|
||||
Декодировать и верифицировать JWT токен.
|
||||
|
||||
Raises:
|
||||
HTTPException: если токен невалиден или просрочен.
|
||||
Декодировать JWT и вернуть user_id.
|
||||
Raises HTTPException 401 при любой проблеме с токеном.
|
||||
"""
|
||||
try:
|
||||
payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
|
||||
user_id: int | None = payload.get("sub")
|
||||
if user_id is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="Неверный токен аутентификации",
|
||||
headers={"WWW-Authenticate": "Bearer"},
|
||||
)
|
||||
return payload
|
||||
except JWTError:
|
||||
sub = payload.get("sub")
|
||||
if sub is None:
|
||||
raise ValueError("missing sub")
|
||||
return int(sub)
|
||||
except (JWTError, ValueError):
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_401_UNAUTHORIZED,
|
||||
detail="Невалидный или просроченный токен",
|
||||
@@ -65,46 +61,79 @@ def verify_token(token: str) -> dict[str, Any]:
|
||||
)
|
||||
|
||||
|
||||
async def get_current_user(
|
||||
token: str = Depends(oauth2_scheme),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""
|
||||
FastAPI dependency: получить текущего авторизованного пользователя из JWT токена.
|
||||
async def _load_user(user_id: int, db: AsyncSession):
|
||||
"""Загрузить пользователя из Redis-кэша или из БД."""
|
||||
from app.models.user import User # избегаем circular import на уровне модуля
|
||||
|
||||
Raises:
|
||||
HTTPException 401: если токен невалиден.
|
||||
HTTPException 404: если пользователь не найден.
|
||||
"""
|
||||
from app.models.user import User
|
||||
cache_key = f"user:cache:{user_id}"
|
||||
r = get_redis()
|
||||
|
||||
payload = verify_token(token)
|
||||
user_id: int = int(payload.get("sub"))
|
||||
# Пробуем кэш
|
||||
cached = await r.get(cache_key)
|
||||
if cached:
|
||||
data = json.loads(cached)
|
||||
# Возвращаем "живой" объект из БД только по id, но без лишнего SELECT
|
||||
# Создаём User без ORM-связей (достаточно для проверок в роутерах)
|
||||
u = User.__new__(User)
|
||||
u.__dict__.update(data)
|
||||
return u
|
||||
|
||||
# Кэш пустой — идём в БД
|
||||
result = await db.execute(select(User).where(User.id == user_id))
|
||||
user = result.scalar_one_or_none()
|
||||
|
||||
if user is None:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_404_NOT_FOUND,
|
||||
detail="Пользователь не найден",
|
||||
)
|
||||
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Пользователь не найден")
|
||||
|
||||
# Сохраняем в кэш (только безопасные поля, без hashed_password)
|
||||
safe = {
|
||||
"id": user.id,
|
||||
"email": user.email,
|
||||
"name": user.name,
|
||||
"plan": user.plan,
|
||||
"is_verified": user.is_verified,
|
||||
}
|
||||
await r.setex(cache_key, _USER_CACHE_TTL, json.dumps(safe))
|
||||
|
||||
return user
|
||||
|
||||
|
||||
async def get_current_verified_user(
|
||||
current_user=Depends(get_current_user),
|
||||
async def get_current_user(
|
||||
token: str = Depends(oauth2_scheme),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""
|
||||
FastAPI dependency: только верифицированные пользователи.
|
||||
"""Dependency: текущий пользователь из JWT с Redis-кэшем."""
|
||||
user_id = _decode_token(token)
|
||||
return await _load_user(user_id, db)
|
||||
|
||||
Raises:
|
||||
HTTPException 403: если email не подтверждён.
|
||||
"""
|
||||
|
||||
async def get_current_verified_user(current_user=Depends(get_current_user)):
|
||||
"""Dependency: только верифицированные пользователи."""
|
||||
if not current_user.is_verified:
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_403_FORBIDDEN,
|
||||
detail="Необходимо подтвердить email адрес",
|
||||
)
|
||||
return current_user
|
||||
|
||||
|
||||
async def get_ws_user(
|
||||
websocket: WebSocket,
|
||||
token: str = Query(..., description="JWT токен (передаётся как query-параметр ?token=...)"),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""
|
||||
Dependency для WebSocket: аутентификация через query-параметр ?token=JWT.
|
||||
|
||||
WebSocket API браузера не позволяет передавать Authorization header,
|
||||
поэтому токен передаётся в query-строке:
|
||||
ws://host/ws/tasks/{public_id}?token=<JWT>
|
||||
"""
|
||||
user_id = _decode_token(token)
|
||||
return await _load_user(user_id, db)
|
||||
|
||||
|
||||
async def invalidate_user_cache(user_id: int) -> None:
|
||||
"""Сбросить кэш пользователя (при смене тарифа, пароля и т.д.)."""
|
||||
r = get_redis()
|
||||
await r.delete(f"user:cache:{user_id}")
|
||||
|
||||
Reference in New Issue
Block a user