Files
mtusi2026lab2/src/app/storage/memory.py
T

177 lines
6.4 KiB
Python

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() # единственный экземпляр хранилища на процесс