Files
mtusi2026lab2/src/app/web.py
T

188 lines
7.3 KiB
Python

"""Общий HTTP-слой: ошибки, запрос, валидация, курсоры, ответы, журнал."""
import base64
import json
import re
import sys
import time
import uuid
from datetime import datetime, timedelta, timezone
from urllib.parse import parse_qsl
from . import config
UUID_RE = re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
LIMIT_RE = re.compile(r"[0-9]{1,9}")
EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
class ApiError(Exception):
def __init__(self, status, code, message, headers=None):
super().__init__(message)
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
def bad(message):
return ApiError(400, "invalid_request", message)
def unavailable(message="Зависимость временно недоступна"):
return ApiError(503, "unavailable", message, {"retry-after": str(config.RETRY_AFTER_SECONDS)})
def log(level, msg, **fields):
record = {"ts": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "level": level, "msg": msg}
record.update(fields)
sys.stdout.write(json.dumps(record, ensure_ascii=False) + "\n")
sys.stdout.flush()
# --- время -------------------------------------------------------------------
def format_dt(value):
value = value.astimezone(timezone.utc)
return value.strftime("%Y-%m-%dT%H:%M:%S.") + "%06dZ" % value.microsecond
def dt_to_us(value):
return (value - EPOCH) // timedelta(microseconds=1)
def us_to_dt(us):
return EPOCH + timedelta(microseconds=us)
# --- валидация ---------------------------------------------------------------
def parse_uuid(value, what="id"):
if not isinstance(value, str) or not UUID_RE.fullmatch(value):
raise bad("Некорректный %s" % what)
return value.lower()
def valid_text(value, field, maximum, allow_empty=False):
if not isinstance(value, str):
raise bad("Поле %s должно быть строкой" % field)
try:
value.encode("utf-8")
except UnicodeEncodeError:
raise bad("Поле %s содержит некорректные символы" % field) from None
if "\x00" in value:
raise bad("Поле %s содержит NUL" % field)
if len(value) > maximum:
raise bad("Поле %s слишком длинное" % field)
if not allow_empty and not value.strip():
raise bad("Поле %s не может быть пустым" % field)
return value
def _reject_constant(name):
raise ValueError(name)
def parse_json_object(raw, required, allowed):
try:
data = json.loads(raw.decode("utf-8"), parse_constant=_reject_constant)
except (UnicodeDecodeError, ValueError, RecursionError):
raise bad("Тело запроса — некорректный JSON") from None
if not isinstance(data, dict):
raise bad("Ожидается JSON-объект")
if set(data) - allowed:
raise bad("Лишние поля в запросе")
if any(key not in data for key in required):
raise bad("Не хватает обязательных полей")
return data
def encode_cursor(kind, resource, key):
payload = json.dumps({"k": kind, "r": resource, "t": key[0], "i": key[1]}, separators=(",", ":"))
return base64.urlsafe_b64encode(payload.encode()).decode().rstrip("=")
def decode_cursor(text, kind, resource):
try:
data = json.loads(base64.urlsafe_b64decode(text + "=" * (-len(text) % 4)).decode())
if (not isinstance(data, dict) or data.get("k") != kind or data.get("r") != resource
or not isinstance(data.get("t"), int) or isinstance(data.get("t"), bool)
or not isinstance(data.get("i"), str) or not UUID_RE.fullmatch(data["i"])
or not -62135596800000000 < data["t"] < 253402300799000000):
raise ValueError
return data["t"], data["i"]
except (ValueError, UnicodeError):
raise bad("Некорректный cursor") from None
def page_params(query, kind, resource):
limit, cursor = 50, None
if "limit" in query:
if len(query["limit"]) != 1 or not LIMIT_RE.fullmatch(query["limit"][0]):
raise bad("limit должен быть целым числом 1–100")
limit = int(query["limit"][0])
if not 1 <= limit <= 100:
raise bad("limit должен быть целым числом 1–100")
if "cursor" in query:
if len(query["cursor"]) != 1 or not query["cursor"][0]:
raise bad("Некорректный cursor")
cursor = decode_cursor(query["cursor"][0], kind, resource)
return limit, cursor
def parse_query(raw):
result = {}
if raw:
for key, value in parse_qsl(raw.decode("latin-1"), keep_blank_values=True):
result.setdefault(key, []).append(value)
return result
class Request:
def __init__(self, scope, receive, request_id):
self.method = scope["method"]
self.path = scope["path"]
self.query = parse_query(scope.get("query_string", b""))
self.headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in scope["headers"]}
self.receive = receive
self.request_id = request_id
self.user_id = None
async def body(self):
declared = self.headers.get("content-length")
if declared is not None:
if not declared.isdigit():
raise bad("Некорректный Content-Length")
if int(declared) > config.MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"connection": "close"})
chunks, size = [], 0
while True:
event = await self.receive()
if event["type"] == "http.disconnect":
raise bad("Соединение закрыто клиентом")
chunk = event.get("body", b"")
size += len(chunk)
if size > config.MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"connection": "close"})
chunks.append(chunk)
if not event.get("more_body"):
return b"".join(chunks)
def require_json_media_type(self):
media = self.headers.get("content-type", "").split(";")[0].strip().lower()
if media != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается Content-Type: application/json")
async def respond(send, status, body, request_id, extra=None, instance_id=None):
payload = b"" if status == 204 else json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
headers = [(b"x-request-id", request_id.encode())]
if status != 204:
headers += [(b"content-type", b"application/json"), (b"content-length", str(len(payload)).encode())]
else:
headers.append((b"content-length", b"0"))
if instance_id:
headers.append((b"x-instance-id", instance_id.encode()))
headers += [(k.encode(), v.encode()) for k, v in (extra or {}).items()]
await send({"type": "http.response.start", "status": status, "headers": headers})
await send({"type": "http.response.body", "body": payload})
def new_request_id():
return uuid.uuid4().hex