"""Общий 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