215 lines
8.1 KiB
Python
215 lines
8.1 KiB
Python
"""
|
||
Redis Service для кеширования, rate limiting, сессий
|
||
"""
|
||
import redis.asyncio as redis
|
||
from typing import Optional, Any, List
|
||
import json
|
||
from ..config import settings
|
||
import logging
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
class RedisService:
|
||
"""Сервис для работы с Redis"""
|
||
|
||
def __init__(self):
|
||
self.client: Optional[redis.Redis] = None
|
||
|
||
async def connect(self):
|
||
"""Подключение к Redis"""
|
||
try:
|
||
self.client = await redis.from_url(
|
||
settings.redis_url,
|
||
encoding="utf-8",
|
||
decode_responses=True
|
||
)
|
||
await self.client.ping()
|
||
logger.info(f"✅ Redis connected: {settings.redis_host}:{settings.redis_port}")
|
||
except Exception as e:
|
||
logger.error(f"❌ Redis connection error: {e}")
|
||
raise
|
||
|
||
async def disconnect(self):
|
||
"""Отключение от Redis"""
|
||
if self.client:
|
||
await self.client.close()
|
||
logger.info("Redis connection closed")
|
||
|
||
async def get(self, key: str) -> Optional[str]:
|
||
"""Получить значение по ключу"""
|
||
full_key = f"{settings.redis_prefix}{key}"
|
||
return await self.client.get(full_key)
|
||
|
||
async def set(self, key: str, value: Any, expire: Optional[int] = None):
|
||
"""Установить значение с опциональным TTL (в секундах)"""
|
||
full_key = f"{settings.redis_prefix}{key}"
|
||
if isinstance(value, (dict, list)):
|
||
value = json.dumps(value)
|
||
if expire:
|
||
await self.client.setex(full_key, expire, value)
|
||
else:
|
||
await self.client.set(full_key, value)
|
||
|
||
async def publish(self, channel: str, message: str):
|
||
"""Публикация сообщения в канал Redis Pub/Sub"""
|
||
try:
|
||
subscribers_count = await self.client.publish(channel, message)
|
||
logger.info(
|
||
f"📢 Redis publish: channel={channel}, message_length={len(message)}, subscribers={subscribers_count}"
|
||
)
|
||
if subscribers_count == 0:
|
||
logger.warning(
|
||
f"⚠️ No subscribers on channel {channel}. Message published but no one is listening!"
|
||
)
|
||
return subscribers_count
|
||
except Exception as e:
|
||
logger.error(f"❌ Redis publish error: {e}")
|
||
raise
|
||
|
||
async def delete(self, key: str) -> bool:
|
||
"""Удалить ключ"""
|
||
full_key = f"{settings.redis_prefix}{key}"
|
||
result = await self.client.delete(full_key)
|
||
return result > 0
|
||
|
||
async def exists(self, key: str) -> bool:
|
||
"""Проверить существование ключа"""
|
||
full_key = f"{settings.redis_prefix}{key}"
|
||
return await self.client.exists(full_key) > 0
|
||
|
||
async def increment(self, key: str, amount: int = 1) -> int:
|
||
"""Инкремент значения"""
|
||
full_key = f"{settings.redis_prefix}{key}"
|
||
return await self.client.incrby(full_key, amount)
|
||
|
||
async def expire(self, key: str, seconds: int):
|
||
"""Установить TTL для ключа"""
|
||
full_key = f"{settings.redis_prefix}{key}"
|
||
await self.client.expire(full_key, seconds)
|
||
|
||
async def get_json(self, key: str) -> Optional[dict]:
|
||
"""Получить JSON значение"""
|
||
value = await self.get(key)
|
||
if value:
|
||
try:
|
||
return json.loads(value)
|
||
except json.JSONDecodeError:
|
||
return None
|
||
return None
|
||
|
||
async def set_json(self, key: str, value: dict, expire: Optional[int] = None):
|
||
"""Установить JSON значение"""
|
||
await self.set(key, json.dumps(value), expire)
|
||
|
||
async def health_check(self) -> bool:
|
||
"""Проверка здоровья Redis"""
|
||
try:
|
||
return await self.client.ping()
|
||
except Exception as e:
|
||
logger.error(f"Redis health check failed: {e}")
|
||
return False
|
||
|
||
# ============================================
|
||
# RATE LIMITING
|
||
# ============================================
|
||
|
||
async def check_rate_limit(self, identifier: str, max_requests: int, window_seconds: int) -> tuple[bool, int]:
|
||
"""
|
||
Проверка rate limiting
|
||
Returns: (allowed: bool, remaining: int)
|
||
"""
|
||
key = f"ratelimit:{identifier}"
|
||
full_key = f"{settings.redis_prefix}{key}"
|
||
|
||
current = await self.client.get(full_key)
|
||
|
||
if current is None:
|
||
# Первый запрос в окне
|
||
await self.client.setex(full_key, window_seconds, 1)
|
||
return True, max_requests - 1
|
||
|
||
current_count = int(current)
|
||
|
||
if current_count >= max_requests:
|
||
# Лимит превышен
|
||
ttl = await self.client.ttl(full_key)
|
||
return False, 0
|
||
|
||
# Инкремент счетчика
|
||
new_count = await self.client.incr(full_key)
|
||
return True, max_requests - new_count
|
||
|
||
# ============================================
|
||
# CACHE
|
||
# ============================================
|
||
|
||
async def cache_get(self, cache_key: str) -> Optional[Any]:
|
||
"""Получить из кеша"""
|
||
return await self.get_json(f"cache:{cache_key}")
|
||
|
||
async def cache_set(self, cache_key: str, value: Any, ttl: int = 3600):
|
||
"""Сохранить в кеш (TTL по умолчанию 1 час)"""
|
||
await self.set_json(f"cache:{cache_key}", value, ttl)
|
||
|
||
async def cache_delete(self, cache_key: str):
|
||
"""Удалить из кеша"""
|
||
await self.delete(f"cache:{cache_key}")
|
||
|
||
# ============================================
|
||
# MESSAGE BUFFER (для буферизации сообщений при недоступности workflow)
|
||
# ============================================
|
||
|
||
async def buffer_push(self, buffer_key: str, message: dict):
|
||
"""
|
||
Добавить сообщение в буфер (очередь)
|
||
|
||
Args:
|
||
buffer_key: Имя буфера (например, "description")
|
||
message: Сообщение для буферизации
|
||
"""
|
||
full_key = f"{settings.redis_prefix}buffer:{buffer_key}"
|
||
await self.client.lpush(full_key, json.dumps(message))
|
||
# Устанавливаем TTL на буфер (24 часа)
|
||
await self.client.expire(full_key, 86400)
|
||
|
||
async def buffer_get_all(self, buffer_key: str) -> List[dict]:
|
||
"""
|
||
Получить все сообщения из буфера (и очистить буфер)
|
||
|
||
Args:
|
||
buffer_key: Имя буфера
|
||
|
||
Returns:
|
||
Список сообщений
|
||
"""
|
||
full_key = f"{settings.redis_prefix}buffer:{buffer_key}"
|
||
|
||
# Используем транзакцию для атомарности
|
||
pipe = self.client.pipeline()
|
||
pipe.lrange(full_key, 0, -1) # Получить все
|
||
pipe.delete(full_key) # Удалить буфер
|
||
results = await pipe.execute()
|
||
|
||
messages_data = results[0] if results else []
|
||
|
||
messages = []
|
||
for msg_str in messages_data:
|
||
try:
|
||
messages.append(json.loads(msg_str))
|
||
except json.JSONDecodeError:
|
||
logger.warning(f"⚠️ Не удалось распарсить сообщение из буфера: {msg_str}")
|
||
|
||
# Возвращаем в правильном порядке (FIFO - сначала старые)
|
||
return list(reversed(messages))
|
||
|
||
async def buffer_size(self, buffer_key: str) -> int:
|
||
"""Получить размер буфера"""
|
||
full_key = f"{settings.redis_prefix}buffer:{buffer_key}"
|
||
return await self.client.llen(full_key)
|
||
|
||
|
||
# Глобальный экземпляр
|
||
redis_service = RedisService()
|
||
|