129 lines
2.9 KiB
Python
129 lines
2.9 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
import os
|
|
from datetime import datetime, timezone
|
|
from uuid import UUID
|
|
|
|
from redis.asyncio import Redis
|
|
from redis.exceptions import RedisError
|
|
|
|
from app.store import store
|
|
|
|
|
|
logger = logging.getLogger("messenger.cache")
|
|
|
|
CACHE_TTL_SECONDS = int(
|
|
os.getenv("USER_CACHE_TTL_SECONDS", "60")
|
|
)
|
|
|
|
if not 1 <= CACHE_TTL_SECONDS <= 3600:
|
|
raise ValueError(
|
|
"USER_CACHE_TTL_SECONDS must be between 1 and 3600"
|
|
)
|
|
|
|
|
|
redis_client = Redis(
|
|
host=os.getenv("REDIS_HOST", "redis"),
|
|
port=int(os.getenv("REDIS_PORT", "6379")),
|
|
decode_responses=True,
|
|
socket_connect_timeout=0.2,
|
|
socket_timeout=0.2,
|
|
retry_on_timeout=False,
|
|
max_connections=10,
|
|
)
|
|
|
|
|
|
def serialize_user(user: dict) -> str:
|
|
created_at = user["created_at"]
|
|
|
|
return json.dumps(
|
|
{
|
|
"id": str(user["id"]),
|
|
"username": user["username"],
|
|
"display_name": user["display_name"],
|
|
"created_at": created_at.astimezone(
|
|
timezone.utc
|
|
).isoformat().replace("+00:00", "Z"),
|
|
},
|
|
ensure_ascii=False,
|
|
separators=(",", ":"),
|
|
)
|
|
|
|
|
|
def deserialize_user(
|
|
raw: str,
|
|
expected_id: UUID,
|
|
) -> dict:
|
|
data = json.loads(raw)
|
|
|
|
if not isinstance(data, dict):
|
|
raise ValueError("Invalid cached user")
|
|
|
|
expected_fields = {
|
|
"id",
|
|
"username",
|
|
"display_name",
|
|
"created_at",
|
|
}
|
|
|
|
if set(data) != expected_fields:
|
|
raise ValueError("Invalid cached user fields")
|
|
|
|
if not all(isinstance(value, str) for value in data.values()):
|
|
raise ValueError("Invalid cached user types")
|
|
|
|
user_id = UUID(data["id"])
|
|
|
|
if user_id != expected_id:
|
|
raise ValueError("Cached user ID mismatch")
|
|
|
|
created_at = datetime.fromisoformat(
|
|
data["created_at"].replace("Z", "+00:00")
|
|
)
|
|
|
|
if created_at.tzinfo is None:
|
|
raise ValueError("Cached timestamp has no timezone")
|
|
|
|
return {
|
|
"id": user_id,
|
|
"username": data["username"],
|
|
"display_name": data["display_name"],
|
|
"created_at": created_at,
|
|
}
|
|
|
|
|
|
async def get_cached_user(user_id: UUID) -> dict | None:
|
|
key = f"user:v1:{user_id}"
|
|
|
|
try:
|
|
raw = await redis_client.get(key)
|
|
|
|
if raw is not None:
|
|
return deserialize_user(raw, user_id)
|
|
|
|
except RedisError:
|
|
logger.warning("User cache read unavailable")
|
|
except (ValueError, TypeError, OverflowError):
|
|
logger.warning("Invalid user cache entry ignored")
|
|
|
|
user = await store.get_user(user_id)
|
|
|
|
if user is None:
|
|
return None
|
|
|
|
try:
|
|
await redis_client.set(
|
|
key,
|
|
serialize_user(user),
|
|
ex=CACHE_TTL_SECONDS,
|
|
)
|
|
except RedisError:
|
|
logger.warning("User cache write unavailable")
|
|
|
|
return user
|
|
|
|
|
|
async def close_cache() -> None:
|
|
await redis_client.aclose() |