import hashlib import hmac import secrets import threading from datetime import datetime, timedelta, timezone from typing import Dict, List, Optional from uuid import UUID, uuid4 from ..models.schemas import Chat, Message, User def now_utc() -> datetime: """Время сервера в UTC с суффиксом Z на выходе.""" return datetime.now(timezone.utc) # --- Password KDF (stdlib scrypt) --- _SCRYPT_N = 2 ** 14 _SCRYPT_R = 8 _SCRYPT_P = 1 _SCRYPT_DKLEN = 32 def _hash_password(password: str) -> str: salt = secrets.token_bytes(16) dk = hashlib.scrypt( password.encode("utf-8"), salt=salt, n=_SCRYPT_N, r=_SCRYPT_R, p=_SCRYPT_P, dklen=_SCRYPT_DKLEN, ) return "scrypt$%d$%d$%d$%s$%s" % ( _SCRYPT_N, _SCRYPT_R, _SCRYPT_P, salt.hex(), dk.hex(), ) def _verify_password(password: str, stored: str) -> bool: try: scheme, n, r, p, salt_hex, dk_hex = stored.split("$") if scheme != "scrypt": return False dk = hashlib.scrypt( password.encode("utf-8"), salt=bytes.fromhex(salt_hex), n=int(n), r=int(r), p=int(p), dklen=len(bytes.fromhex(dk_hex)), ) return hmac.compare_digest(dk.hex(), dk_hex) except Exception: return False class MemoryStorage: """Потокобезопасное In-memory хранилище пользователей, чатов, сообщений и сессий. Все данные исчезают при перезапуске процесса""" def __init__(self) -> None: self._lock = threading.RLock() self._users: Dict[UUID, User] = {} self._usernames: Dict[str, UUID] = {} self._passwords: Dict[UUID, str] = {} self._chats: Dict[UUID, Chat] = {} self._messages: Dict[UUID, List[Message]] = {} # token -> (user_id, expires_at) self._sessions: Dict[str, tuple] = {} # ---------- Пользователи ---------- def create_user(self, username: str, display_name: str, password: str) -> User: with self._lock: if username in self._usernames: raise ValueError("username_taken") user = User( id=uuid4(), username=username, display_name=display_name, created_at=now_utc(), ) self._users[user.id] = user self._usernames[username] = user.id self._passwords[user.id] = _hash_password(password) return user def get_user(self, user_id: UUID) -> Optional[User]: with self._lock: return self._users.get(user_id) def get_user_by_username(self, username: str) -> Optional[User]: with self._lock: uid = self._usernames.get(username) return self._users.get(uid) if uid else None def verify_credentials(self, username: str, password: str) -> Optional[User]: with self._lock: uid = self._usernames.get(username) if uid is None: return None stored = self._passwords.get(uid) if not stored or not _verify_password(password, stored): return None return self._users.get(uid) # ---------- Сессии ---------- def create_session(self, user_id: UUID, ttl_seconds: int) -> tuple: with self._lock: token = secrets.token_urlsafe(32) expires_at = now_utc() + timedelta(seconds=ttl_seconds) self._sessions[token] = (user_id, expires_at) return token, expires_at def get_session_user(self, token: str) -> Optional[User]: with self._lock: entry = self._sessions.get(token) if entry is None: return None user_id, expires_at = entry if expires_at <= now_utc(): self._sessions.pop(token, None) return None return self._users.get(user_id) def revoke_session(self, token: str) -> None: with self._lock: self._sessions.pop(token, None) # ---------- Чаты ---------- def create_chat(self, title: str, member_ids: List[UUID]) -> Chat: with self._lock: for uid in member_ids: if uid not in self._users: raise ValueError("unknown_member") chat = Chat( id=uuid4(), title=title, member_ids=list(member_ids), created_at=now_utc(), ) self._chats[chat.id] = chat self._messages[chat.id] = [] return chat def get_chat(self, chat_id: UUID) -> Optional[Chat]: with self._lock: return self._chats.get(chat_id) def list_chats_for_user(self, user_id: UUID) -> List[Chat]: with self._lock: chats = [c for c in self._chats.values() if user_id in c.member_ids] chats.sort(key=lambda c: (c.created_at, str(c.id))) return chats # ---------- Сообщения ---------- def add_message(self, chat_id: UUID, sender_id: UUID, text: str) -> Message: """Улучшение Трека 1: список сообщений хранится уже отсортированным. created_at монотонен в пределах одного процесса, поэтому append сохраняет порядок (created_at, id) по возрастанию — сортировка на чтении не нужна. При конкурентных вставках под RLock порядок сохраняется, но монотонность часов не гарантируется контрактом.""" with self._lock: message = Message( id=uuid4(), chat_id=chat_id, sender_id=sender_id, text=text, created_at=now_utc(), ) self._messages.setdefault(chat_id, []).append(message) return message def list_messages(self, chat_id: UUID) -> List[Message]: with self._lock: # Без пересортировки: список уже в порядке (created_at, id). return list(self._messages.get(chat_id, [])) storage = MemoryStorage() # единственный экземпляр хранилища на процесс