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