PostgreSQL как источник истины, непрозрачные сессии в Redis с TTL и AOF, миграции под advisory lock, пул и таймауты, проверки гонки/отката/отказов и отчёт с evidence.
144 lines
5.0 KiB
Python
144 lines
5.0 KiB
Python
"""Strict parsing shared by HTTP handlers.
|
|
|
|
The contract requires rejection of extra JSON fields, wrong types and
|
|
whitespace-only required strings. Validation happens before any SQL.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import binascii
|
|
import json
|
|
import re
|
|
import uuid
|
|
from datetime import datetime, timezone
|
|
|
|
from flask import Request
|
|
|
|
from .errors import ApiError, bad_request
|
|
|
|
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
|
|
INTEGER_RE = re.compile(r"^[0-9]+$")
|
|
|
|
|
|
def json_object(request: Request, max_bytes: int) -> dict:
|
|
if request.mimetype != "application/json":
|
|
raise bad_request("Ожидается application/json")
|
|
raw = request.get_data(cache=False)
|
|
if not raw:
|
|
raise bad_request("Тело запроса обязательно")
|
|
if len(raw) > max_bytes:
|
|
raise ApiError(413, "payload_too_large", "Тело запроса слишком велико")
|
|
try:
|
|
value = json.loads(raw)
|
|
except (ValueError, UnicodeError) as exc:
|
|
raise bad_request("Некорректный JSON") from exc
|
|
if not isinstance(value, dict):
|
|
raise bad_request("Ожидается JSON-объект")
|
|
return value
|
|
|
|
|
|
def exact_keys(value: dict, required: tuple[str, ...], optional: tuple[str, ...] = ()) -> None:
|
|
allowed = set(required) | set(optional)
|
|
if not set(required).issubset(value) or set(value) - allowed:
|
|
raise bad_request("Неверный набор полей")
|
|
|
|
|
|
def text_field(value: object, name: str, minimum: int, maximum: int) -> str:
|
|
if not isinstance(value, str):
|
|
raise bad_request(f"Поле {name} должно быть строкой")
|
|
if not (minimum <= len(value) <= maximum):
|
|
raise bad_request(f"Поле {name} имеет недопустимую длину")
|
|
return value
|
|
|
|
|
|
def non_blank(value: object, name: str, minimum: int, maximum: int) -> str:
|
|
result = text_field(value, name, minimum, maximum)
|
|
if not result.strip():
|
|
raise bad_request(f"Поле {name} не должно быть пустым")
|
|
return result
|
|
|
|
|
|
def username(value: object) -> str:
|
|
result = text_field(value, "username", 3, 32)
|
|
if USERNAME_RE.fullmatch(result) is None:
|
|
raise bad_request("Недопустимый username")
|
|
return result
|
|
|
|
|
|
def display_name(value: object) -> str:
|
|
return non_blank(value, "display_name", 1, 100)
|
|
|
|
|
|
def password(value: object) -> str:
|
|
result = text_field(value, "password", 12, 128)
|
|
return result
|
|
|
|
|
|
def message_text(value: object) -> str:
|
|
return non_blank(value, "text", 1, 4000)
|
|
|
|
|
|
def uuid_list(value: object, name: str, minimum: int = 1, maximum: int = 100) -> list[str]:
|
|
if not isinstance(value, list):
|
|
raise bad_request(f"Поле {name} должно быть массивом")
|
|
if not (minimum <= len(value) <= maximum):
|
|
raise bad_request(f"Поле {name} имеет недопустимую длину")
|
|
parsed: list[str] = []
|
|
for item in value:
|
|
parsed.append(str(uuid_value(item, name)))
|
|
if len(set(parsed)) != len(parsed):
|
|
raise bad_request(f"Поле {name} содержит дубликаты")
|
|
return parsed
|
|
|
|
|
|
def uuid_value(value: object, name: str = "id") -> uuid.UUID:
|
|
if not isinstance(value, str):
|
|
raise bad_request(f"Поле {name} должно быть UUID")
|
|
try:
|
|
return uuid.UUID(value)
|
|
except (ValueError, AttributeError) as exc:
|
|
raise bad_request(f"Поле {name} должно быть UUID") from exc
|
|
|
|
|
|
def limit_arg(raw: str | None, default: int = 50) -> int:
|
|
if raw is None:
|
|
return default
|
|
if INTEGER_RE.fullmatch(raw) is None:
|
|
raise bad_request("limit должен быть целым числом")
|
|
value = int(raw)
|
|
if not (1 <= value <= 100):
|
|
raise bad_request("limit должен быть в диапазоне 1..100")
|
|
return value
|
|
|
|
|
|
def encode_cursor(payload: dict) -> str:
|
|
raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
|
|
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
|
|
|
|
|
def decode_cursor(raw: str | None) -> dict | None:
|
|
if raw is None:
|
|
return None
|
|
if not raw or len(raw) > 4096:
|
|
raise bad_request("Некорректный cursor")
|
|
padded = raw + "=" * (-len(raw) % 4)
|
|
try:
|
|
data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
|
|
except (ValueError, UnicodeError, AttributeError, binascii.Error) as exc:
|
|
raise bad_request("Некорректный cursor") from exc
|
|
if not isinstance(data, dict):
|
|
raise bad_request("Некорректный cursor")
|
|
return data
|
|
|
|
|
|
def cursor_time(value: object) -> datetime:
|
|
if not isinstance(value, str):
|
|
raise bad_request("Некорректный cursor")
|
|
try:
|
|
result = datetime.fromisoformat(value.replace("Z", "+00:00"))
|
|
except ValueError as exc:
|
|
raise bad_request("Некорректный cursor") from exc
|
|
if result.tzinfo is None:
|
|
raise bad_request("Некорректный cursor")
|
|
return result.astimezone(timezone.utc)
|