forked from mtusi2026/mtusi2026lab2
188 lines
7.3 KiB
Python
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
|