435 lines
24 KiB
Python
435 lines
24 KiB
Python
"""lab4–lab5: тестовые картинки и низкоуровневая загрузка — только стандартная библиотека Python.
|
||
|
||
- png(): настоящий PNG любого размера (шум не сжимается — так получаются файлы на 9 МБ);
|
||
- bomb_png(): «бомба» — файл ~150 КБ, внутри 42 млн пикселей (больше лимита 40 млн);
|
||
- SAMPLE_JPEG: синтетический JPEG 48×32 (781 байт), создан для курса программно;
|
||
- garbage_scan_jpeg(): JPEG с правильной структурой, но мусором вместо сжатых данных (lab5:
|
||
API его принимает — структура цела, а worker при строгом декодировании даёт invalid_image);
|
||
- bad_filter_png(): PNG с недопустимым типом фильтра строки (lab5: 415 уже в API);
|
||
- raw_upload(): POST через сокет. Нужен там, где urllib не справится: сервер отвечает 413
|
||
и закрывает соединение, пока клиент ещё отправляет тело, или клиент сам обрывает передачу;
|
||
- in_api() / psql(): выполнить код внутри контейнера API или SQL в PostgreSQL (для проверок
|
||
S3 и уборщика). Секреты не печатаются: код внутри контейнера сам читает их из /run/secrets.
|
||
"""
|
||
import base64
|
||
import json
|
||
import os
|
||
import select
|
||
import socket
|
||
import struct
|
||
import subprocess
|
||
import time
|
||
import zlib
|
||
from urllib.parse import urlsplit
|
||
|
||
from helpers import ROOT, Failure, check
|
||
|
||
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
|
||
|
||
SAMPLE_PNG = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes()
|
||
SAMPLE_JPEG = base64.b64decode(
|
||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYn"
|
||
"KSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo"
|
||
"KCgoKCgoKCj/wAARCAAgADADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUF"
|
||
"BAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW"
|
||
"V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi"
|
||
"4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAEC"
|
||
"AxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVm"
|
||
"Z2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq"
|
||
"8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDwGCw9q0ILD2rcgsPatCCw9q+pqYw4MFj9tTDgsPatCCw9q24LD2rQgsPauCpjD67BY/bU"
|
||
"xILD2q/BYe1bkFh7VoQWHtXBUxh9dgsftqc3BYe1aEFh7VuQWHtWhBYe1cdTGH824LH7amHBYe1aEFh7VuQWHtWhBYe1cFTGH12C"
|
||
"x+2phwWHtWhBYe1bkFh7VoQWHtXn1MYfXYLH7an/2Q==")
|
||
# Ещё два синтетических JPEG 40×24 (созданы для курса Pillow): progressive и с маркерами RST (DRI = 1 MCU).
|
||
PROGRESSIVE_JPEG = base64.b64decode(
|
||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
|
||
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
|
||
"T0//wgARCAAYACgDASIAAhEBAxEB/8QAFwABAQEBAAAAAAAAAAAAAAAAAAMEBf/EABgBAAMBAQAAAAAAAAAAAAAAAAIDBAEG/9oADAMB"
|
||
"AAIQAxAAAAHg11WxeWuqzbMreOuNSLlrVG22B1f/xAAWEAADAAAAAAAAAAAAAAAAAAAAAQL/2gAIAQEAAQUCUCgUCgUCgUCgUCgUCgUC"
|
||
"gUH/xAAXEQADAQAAAAAAAAAAAAAAAAAAAQID/9oACAEDAQE/AY2I2FsRTIpipn//xAAXEQEBAQEAAAAAAAAAAAAAAAABABAR/9oACAEC"
|
||
"AQE/ARhuxGf/xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAY/An//xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAE/IXAAAAA/"
|
||
"/9oADAMBAAIAAwAAABBpk59wP//EABcRAQADAAAAAAAAAAAAAAAAABAAESH/2gAIAQMBAT8QKydq0//EABYRAQEBAAAAAAAAAAAAAAAA"
|
||
"AAEAEP/aAAgBAgEBPxDPK2bC3//EABUQAQEAAAAAAAAAAAAAAAAAAABh/9oACAEBAAE/EJJJJJJJJJJJJJJJP//Z")
|
||
RESTART_JPEG = base64.b64decode(
|
||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
|
||
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
|
||
"T0//wAARCAAYACgDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQID"
|
||
"AAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlq"
|
||
"c3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3"
|
||
"+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEI"
|
||
"FEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImK"
|
||
"kpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/90ABAAB/9oADAMBAAIR"
|
||
"AxEAPwDg4rP2q3FZ+1akVn7Vbis/alCZz0MYf//Q5mKz9qtxWftWpFZ+1W4rP2rohM9GhjD/0c+Kz9qK34rP2orvUz6aGM0P/9J0Vn7V"
|
||
"bis/aiiuSDZ8pQqyP//T2IrP2q3FZ+1FFTBs82hVkf/U66Kz9qKKK1TZcKsrH//Z")
|
||
|
||
|
||
def _chunk(kind: bytes, data: bytes) -> bytes:
|
||
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
|
||
|
||
|
||
def png(width: int, height: int, noise: bool = False) -> bytes:
|
||
"""RGB PNG. noise=True — случайные пиксели (файл почти не сжимается), иначе однотонный."""
|
||
compressor = zlib.compressobj(1)
|
||
parts = []
|
||
row = b"\x00" + b"\x40\x80\xc0" * width
|
||
for _ in range(height):
|
||
parts.append(compressor.compress(b"\x00" + os.urandom(width * 3) if noise else row))
|
||
parts.append(compressor.flush())
|
||
ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
|
||
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", b"".join(parts)) + _chunk(b"IEND", b"")
|
||
|
||
|
||
def bomb_png() -> bytes:
|
||
"""7000×6000 = 42 млн пикселей нулей: файл маленький, распакованный — 126 МБ."""
|
||
return png(7000, 6000)
|
||
|
||
|
||
def png_exact_size(total: int) -> bytes:
|
||
"""Корректный PNG ровно total байт: маленькая картинка + служебный блок-заполнитель (tEXt)."""
|
||
base = png(64, 64, noise=True)
|
||
head, iend = base[:-12], base[-12:]
|
||
filler = total - len(base) - 12 # 12 байт — длина, тип и CRC блока-заполнителя
|
||
check(filler >= 6, "total is too small")
|
||
return head + _chunk(b"tEXt", b"pad\x00" + b"x" * (filler - 4)) + iend
|
||
|
||
|
||
def gray_png(width: int, height: int) -> bytes:
|
||
"""Оттенки серого, нули: 40 млн пикселей сжимаются в ~40 КБ."""
|
||
compressor = zlib.compressobj(9)
|
||
row = b"\x00" + bytes(width)
|
||
data = b"".join(compressor.compress(row) for _ in range(height)) + compressor.flush()
|
||
ihdr = struct.pack(">IIBBBBB", width, height, 8, 0, 0, 0, 0)
|
||
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", data) + _chunk(b"IEND", b"")
|
||
|
||
|
||
def bad_filter_png() -> bytes:
|
||
"""PNG 40×30, у 11-й строки тип фильтра 7 (допустимы 0–4)."""
|
||
raw = b"".join(bytes([7 if y == 10 else 0]) + bytes(40 * 3) for y in range(30))
|
||
ihdr = struct.pack(">IIBBBBB", 40, 30, 8, 2, 0, 0, 0)
|
||
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", zlib.compress(raw)) + _chunk(b"IEND", b"")
|
||
|
||
|
||
# ---------- JPEG по сегментам: чтобы портить структуру точечно ----------
|
||
|
||
def jpeg_parts(data: bytes) -> list:
|
||
"""JPEG -> [("seg", маркер, данные) | ("scan", заголовок SOS, сжатые данные) | ("eoi", хвост)]."""
|
||
i, parts = 2, []
|
||
while True:
|
||
marker = data[i + 1]
|
||
i += 2
|
||
if marker == 0xD9:
|
||
parts.append(("eoi", data[i:]))
|
||
return parts
|
||
length = int.from_bytes(data[i:i + 2], "big")
|
||
payload, i = data[i + 2:i + length], i + length
|
||
if marker != 0xDA:
|
||
parts.append(("seg", marker, payload))
|
||
continue
|
||
j = i
|
||
while data[j] != 0xFF or data[j + 1] == 0x00 or 0xD0 <= data[j + 1] <= 0xD7:
|
||
j += 1
|
||
parts.append(("scan", payload, data[i:j]))
|
||
i = j
|
||
|
||
|
||
def jpeg_join(parts: list) -> bytes:
|
||
out = bytearray(b"\xff\xd8")
|
||
for part in parts:
|
||
if part[0] == "seg":
|
||
out += bytes([0xFF, part[1]]) + struct.pack(">H", len(part[2]) + 2) + part[2]
|
||
elif part[0] == "scan":
|
||
out += b"\xff\xda" + struct.pack(">H", len(part[1]) + 2) + part[1] + part[2]
|
||
else:
|
||
out += b"\xff\xd9" + part[1]
|
||
return bytes(out)
|
||
|
||
|
||
def _edit(data: bytes, kind, fn, index: int = 0) -> bytes:
|
||
"""Поменять index-й сегмент вида kind (маркер или "scan"): fn(bytearray) -> bytes."""
|
||
parts, seen = jpeg_parts(data), 0
|
||
for k, part in enumerate(parts):
|
||
hit = part[0] == "scan" if kind == "scan" else part[0] == "seg" and part[1] == kind
|
||
if hit:
|
||
if seen == index:
|
||
if kind == "scan":
|
||
parts[k] = ("scan", fn(bytearray(part[1])), part[2])
|
||
else:
|
||
parts[k] = ("seg", kind, fn(bytearray(part[2])))
|
||
return jpeg_join(parts)
|
||
seen += 1
|
||
raise AssertionError(f"segment {kind} #{index} not found")
|
||
|
||
|
||
def _set(position: int, value: int):
|
||
def change(payload: bytearray) -> bytes:
|
||
payload[position] = value
|
||
return bytes(payload)
|
||
return change
|
||
|
||
|
||
def teacher_bad_sos_jpeg() -> bytes:
|
||
"""Воспроизведение из замечания: в первом SOS (FF DA по смещению i) байт i+5 — первый
|
||
идентификатор компонента — заменить на 250, которого нет в SOF."""
|
||
data = bytearray(SAMPLE_JPEG)
|
||
i = data.index(b"\xff\xda")
|
||
data[i + 5] = 250
|
||
return bytes(data)
|
||
|
||
|
||
def broken_structure_jpegs() -> list[tuple[str, bytes]]:
|
||
"""JPEG, которые строгий декодер worker отвергает по маркерам и заголовкам (API: 415)."""
|
||
def drop(data, test):
|
||
return jpeg_join([p for p in jpeg_parts(data) if not test(p)])
|
||
|
||
def scans(data):
|
||
return [p for p in jpeg_parts(data) if p[0] == "scan"]
|
||
|
||
def swap_rst(entropy: bytes) -> bytes:
|
||
e = bytearray(entropy)
|
||
positions = [k for k in range(len(e) - 1) if e[k] == 0xFF and 0xD0 <= e[k + 1] <= 0xD7]
|
||
e[positions[0] + 1], e[positions[1] + 1] = e[positions[1] + 1], e[positions[0] + 1]
|
||
return bytes(e)
|
||
|
||
seq_scan = scans(SAMPLE_JPEG)[0]
|
||
first_progressive = scans(PROGRESSIVE_JPEG)[0]
|
||
no_jfif = drop(SAMPLE_JPEG, lambda p: p[0] == "seg" and p[1] == 0xE0)
|
||
restart_parts = jpeg_parts(RESTART_JPEG)
|
||
return [
|
||
("SOS: компонент 250, которого нет в SOF (замечание к MR)", teacher_bad_sos_jpeg()),
|
||
("SOS: один компонент дважды в скане", _edit(SAMPLE_JPEG, "scan", _set(3, 1))),
|
||
("SOS: таблица Хаффмана DC 2 не определена", _edit(SAMPLE_JPEG, "scan", _set(2, 0x20))),
|
||
("SOS: номер таблицы Хаффмана AC 5", _edit(SAMPLE_JPEG, "scan", _set(4, 0x05))),
|
||
("SOS: Se=62 в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-2, 62))),
|
||
("SOS: Ah/Al не нули в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-1, 0x10))),
|
||
("SOS: 5 компонентов в скане", _edit(SAMPLE_JPEG, "scan", _set(0, 5))),
|
||
("SOF: таблица квантования 3 не определена", _edit(SAMPLE_JPEG, 0xC0, _set(8, 3))),
|
||
("SOF: повторяется идентификатор компонента", _edit(SAMPLE_JPEG, 0xC0, _set(9, 1))),
|
||
("SOF: субдискретизация 1×4 (не понимает декодер)", _edit(SAMPLE_JPEG, 0xC0, _set(7, 0x14))),
|
||
("SOF: коэффициент субдискретизации 0", _edit(SAMPLE_JPEG, 0xC0, _set(10, 0x01))),
|
||
("SOF: 12 бит на канал", _edit(SAMPLE_JPEG, 0xC0, _set(0, 12))),
|
||
("SOF: 2 компонента", _edit(SAMPLE_JPEG, 0xC0, lambda p: bytes(p[:5]) + b"\x02" + bytes(p[6:12]))),
|
||
("DHT: коды не помещаются в длину (3 кода по 1 биту)",
|
||
_edit(SAMPLE_JPEG, 0xC4, lambda p: b"\x00" + bytes([3] + [0] * 15) + b"\x00\x01\x02")),
|
||
("DHT: символ 16 в таблице DC", _edit(SAMPLE_JPEG, 0xC4, lambda p: bytes(p[:-1]) + b"\x10")),
|
||
("DHT: номер таблицы 4", _edit(SAMPLE_JPEG, 0xC4, _set(0, 0x04))),
|
||
("DQT: таблица обрезана", _edit(SAMPLE_JPEG, 0xDB, lambda p: bytes(p[:-1]))),
|
||
("сегмент с зарезервированным маркером 0xF0",
|
||
jpeg_join([("seg", 0xF0, b"\x00\x00")] + jpeg_parts(SAMPLE_JPEG))),
|
||
("мусорные байты между сегментами", SAMPLE_JPEG.replace(b"\xff\xdb", b"\x00\x00\xff\xdb", 1)),
|
||
("APP0: JFIF версии 3", _edit(SAMPLE_JPEG, 0xE0, _set(5, 3))),
|
||
("APP14: неизвестное преобразование Adobe 7",
|
||
jpeg_join([("seg", 0xEE, b"Adobe\x00\x64\x00\x00\x00\x00\x07")] + jpeg_parts(no_jfif))),
|
||
("второй скан после полного скана",
|
||
jpeg_join(jpeg_parts(SAMPLE_JPEG)[:-1] + [seq_scan, ("eoi", b"")])),
|
||
("progressive: AC-скан раньше DC-скана", drop(PROGRESSIVE_JPEG, lambda p: p is not None and p == first_progressive)),
|
||
("progressive: Al=14", _edit(PROGRESSIVE_JPEG, "scan", _set(-1, 14))),
|
||
("RST: маркеры RST0 и RST1 поменяны местами",
|
||
jpeg_join([("scan", p[1], swap_rst(p[2])) if p[0] == "scan" else p for p in restart_parts])),
|
||
("RST: маркеры есть, а интервала DRI нет", drop(RESTART_JPEG, lambda p: p[0] == "seg" and p[1] == 0xDD)),
|
||
("RST: интервал DRI 2 вместо 1", _edit(RESTART_JPEG, 0xDD, lambda p: b"\x00\x02")),
|
||
]
|
||
|
||
|
||
def garbage_scan_jpeg() -> bytes:
|
||
"""SAMPLE_JPEG с мусором вместо сжатых данных скана: маркеры и длины целы, данные — нет."""
|
||
sos = SAMPLE_JPEG.index(b"\xff\xda")
|
||
length = int.from_bytes(SAMPLE_JPEG[sos + 2:sos + 4], "big")
|
||
noise = bytes((i * 37 + 11) % 255 for i in range(400)) # без 0xFF: маркеры не появятся
|
||
return SAMPLE_JPEG[:sos + 2 + length] + noise + b"\xff\xd9"
|
||
|
||
|
||
def corrupt_crc(data: bytes) -> bytes:
|
||
"""Испортить один байт внутри данных IDAT: контрольная сумма блока перестаёт сходиться."""
|
||
position = data.index(b"IDAT") + 8
|
||
return data[:position] + bytes([data[position] ^ 0xFF]) + data[position + 1:]
|
||
|
||
|
||
def truncated(data: bytes) -> bytes:
|
||
return data[: len(data) // 2]
|
||
|
||
|
||
# ---------- загрузка через сокет ----------
|
||
|
||
def raw_upload(path: str, token: str, body: bytes = b"", content_type: str = "image/png",
|
||
content_length: int | None = None, abort_after: int | None = None, timeout: float = 30):
|
||
"""POST path через балансировщик. Возвращает (status, headers, json) или None, если ответа нет.
|
||
|
||
content_length — что заявить в заголовке (по умолчанию len(body));
|
||
abort_after — отправить столько байт тела и оборвать соединение (имитация обрыва загрузки).
|
||
Тело шлётся кусками; если сервер уже ответил (413) и закрыл соединение — перестаём слать
|
||
и читаем ответ.
|
||
"""
|
||
url = urlsplit(BASE_URL)
|
||
sock = socket.create_connection((url.hostname, url.port or 80), timeout=timeout)
|
||
length = len(body) if content_length is None else content_length
|
||
# content_length=-1: Transfer-Encoding: chunked, размер заранее неизвестен серверу.
|
||
framing = "Transfer-Encoding: chunked" if length == -1 else f"Content-Length: {length}"
|
||
head = (f"POST {path} HTTP/1.1\r\nHost: {url.hostname}\r\nAuthorization: Bearer {token}\r\n"
|
||
f"Content-Type: {content_type}\r\n{framing}\r\nConnection: close\r\n\r\n")
|
||
to_send = body if abort_after is None else body[:abort_after]
|
||
if length == -1:
|
||
step = 64 * 1024
|
||
to_send = b"".join(b"%x\r\n%s\r\n" % (len(to_send[i:i + step]), to_send[i:i + step])
|
||
for i in range(0, len(to_send), step)) + b"0\r\n\r\n"
|
||
try:
|
||
sock.sendall(head.encode("ascii"))
|
||
for start in range(0, len(to_send), 64 * 1024):
|
||
# Сервер уже ответил (например, 413 до конца тела)? Тогда перестаём слать и читаем ответ:
|
||
# продолжение отправки в закрытое соединение может стереть ответ (RST).
|
||
if select.select([sock], [], [], 0)[0]:
|
||
break
|
||
sock.sendall(to_send[start:start + 64 * 1024])
|
||
except OSError:
|
||
pass # сервер закрыл соединение раньше — читаем то, что он успел ответить
|
||
if abort_after is not None:
|
||
sock.close()
|
||
return None
|
||
data = b""
|
||
try:
|
||
while True:
|
||
part = sock.recv(65536)
|
||
if not part:
|
||
break
|
||
data += part
|
||
if _complete(data): # ответ получен целиком: не ждём, пока балансировщик закроет соединение
|
||
break
|
||
except OSError:
|
||
pass
|
||
finally:
|
||
sock.close()
|
||
if not data.startswith(b"HTTP/1."):
|
||
return None
|
||
header_blob, _, payload = data.partition(b"\r\n\r\n")
|
||
lines = header_blob.decode("latin-1").split("\r\n")
|
||
status = int(lines[0].split()[1])
|
||
headers = {k.strip().lower(): v.strip() for k, v in (line.split(":", 1) for line in lines[1:] if ":" in line)}
|
||
try:
|
||
payload_json = json.loads(payload.decode("utf-8")) if payload else None
|
||
except ValueError:
|
||
payload_json = None
|
||
return status, headers, payload_json
|
||
|
||
|
||
def _complete(data: bytes) -> bool:
|
||
head, sep, body = data.partition(b"\r\n\r\n")
|
||
if not sep:
|
||
return False
|
||
for line in head.decode("latin-1").split("\r\n")[1:]:
|
||
name, _, value = line.partition(":")
|
||
if name.strip().lower() == "content-length":
|
||
return len(body) >= int(value.strip())
|
||
return False
|
||
|
||
|
||
def upload_when_ready(api, actor, chat, data=None, name="ready.png", seconds=60, ctype="image/png"):
|
||
"""Загрузить файл; пока стенд только запускается (503) — повторять до seconds. Возвращает ответ 202."""
|
||
path = f"/api/v1/chats/{chat['id']}/attachments?filename={name}"
|
||
deadline = time.monotonic() + seconds
|
||
while True:
|
||
try:
|
||
reply = api.call("POST", path, [202, 503], actor=actor, raw=data or SAMPLE_PNG,
|
||
headers={"Content-Type": ctype}, schema="Attachment")
|
||
except Failure: # балансировщик без готовых реплик или обрыв соединения
|
||
reply = {"status": 0}
|
||
if reply["status"] == 202:
|
||
check(reply["json"]["status"] == "queued", "upload must return a queued snapshot")
|
||
return reply
|
||
check(time.monotonic() < deadline, f"stand is not ready for uploads after {seconds} s")
|
||
time.sleep(1)
|
||
|
||
|
||
def wait_status(api, actor, attachment_id, statuses=("ready",), seconds=60, step=0.3):
|
||
"""Опрашивать GET вложения, пока статус не станет одним из statuses. Возвращает Attachment."""
|
||
deadline = time.monotonic() + seconds
|
||
last = None
|
||
while True:
|
||
try:
|
||
last = api.call("GET", f"/api/v1/attachments/{attachment_id}", actor=actor, schema="Attachment")["json"]
|
||
if last["status"] in statuses:
|
||
return last
|
||
check(last["status"] != "failed" or "failed" in statuses,
|
||
f"attachment failed with {last['error_code']}")
|
||
except Failure as exc:
|
||
if "attachment failed" in str(exc):
|
||
raise
|
||
check(time.monotonic() < deadline,
|
||
f"attachment is {last and last['status']} after {seconds} s, expected {statuses}")
|
||
time.sleep(step)
|
||
|
||
|
||
def webp_size(data: bytes) -> tuple[int, int]:
|
||
"""Ширина и высота WebP по заголовку RIFF (VP8, VP8L или VP8X) — без библиотек."""
|
||
check(data[:4] == b"RIFF" and data[8:12] == b"WEBP", "not a WebP file")
|
||
kind = data[12:16]
|
||
if kind == b"VP8 ":
|
||
return int.from_bytes(data[26:28], "little") & 0x3FFF, int.from_bytes(data[28:30], "little") & 0x3FFF
|
||
if kind == b"VP8L":
|
||
bits = int.from_bytes(data[21:25], "little")
|
||
return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
|
||
check(kind == b"VP8X", "unknown WebP chunk")
|
||
return int.from_bytes(data[24:27], "little") + 1, int.from_bytes(data[27:30], "little") + 1
|
||
|
||
|
||
def webp_chunks(data: bytes) -> list[bytes]:
|
||
"""Типы блоков RIFF внутри WebP (EXIF, XMP , ICCP — метаданные)."""
|
||
kinds, i = [], 12
|
||
while i + 8 <= len(data):
|
||
kinds.append(data[i:i + 4])
|
||
i += 8 + ((int.from_bytes(data[i + 4:i + 8], "little") + 1) & ~1)
|
||
return kinds
|
||
|
||
|
||
def jpeg_markers(data: bytes) -> list[int]:
|
||
"""Маркеры JPEG до начала скана: по ним видно, есть ли EXIF (APP1) или ICC (APP2)."""
|
||
found, i = [], 2
|
||
while i + 4 <= len(data) and data[i] == 0xFF:
|
||
marker = data[i + 1]
|
||
found.append(marker)
|
||
if marker == 0xDA:
|
||
break
|
||
i += 2 + int.from_bytes(data[i + 2:i + 4], "big")
|
||
return found
|
||
|
||
|
||
# ---------- внутри стенда ----------
|
||
|
||
def in_api(code: str) -> str:
|
||
"""Выполнить Python-код в контейнере API (сеть backend, модули messenger). Возвращает stdout."""
|
||
result = subprocess.run(["docker", "compose", "exec", "-T", "api", "python", "-"], cwd=ROOT,
|
||
input=code.encode("utf-8"), capture_output=True)
|
||
last_error = (result.stderr.decode("utf-8", "replace").strip().splitlines() or [""])[-1]
|
||
check(result.returncode == 0, "code inside the api container failed: " + last_error)
|
||
return result.stdout.decode("utf-8", "replace").strip()
|
||
|
||
|
||
def exec_python(container: str, code: str) -> str:
|
||
"""Python-код в конкретном контейнере через stdin (переводы строк одинаково работают и на Windows)."""
|
||
result = subprocess.run(["docker", "exec", "-i", container, "python", "-"], cwd=ROOT,
|
||
input=code.encode("utf-8"), capture_output=True)
|
||
check(result.returncode == 0, f"code inside {container[:12]} failed")
|
||
return result.stdout.decode("utf-8", "replace").strip()
|
||
|
||
|
||
def psql(sql: str) -> str:
|
||
"""SQL в PostgreSQL стенда (только для проверок; значения в SQL — проверенные UUID и числа)."""
|
||
result = subprocess.run(["docker", "compose", "exec", "-T", "postgres", "psql", "-X", "-q", "-t", "-A",
|
||
"-U", "messenger", "-d", "messenger", "-v", "ON_ERROR_STOP=1", "-c", sql],
|
||
cwd=ROOT, capture_output=True)
|
||
check(result.returncode == 0, "psql failed: " + result.stderr.decode("utf-8", "replace").strip())
|
||
return result.stdout.decode("utf-8", "replace").strip()
|
||
|
||
|
||
def cleanup_cli(*args: str) -> dict:
|
||
"""python -m messenger.cleanup внутри контейнера API -> словарь счётчиков."""
|
||
result = subprocess.run(["docker", "compose", "exec", "-T", "api", "python", "-m", "messenger.cleanup", *args],
|
||
cwd=ROOT, capture_output=True)
|
||
output = result.stdout.decode("utf-8", "replace").strip().splitlines()
|
||
check(result.returncode == 0 and output, "cleanup failed: " + result.stderr.decode("utf-8", "replace")[-300:])
|
||
return json.loads(output[-1])
|
||
|
||
|
||
def wait_until(condition, seconds: float, message: str, step: float = 0.5):
|
||
deadline = time.monotonic() + seconds
|
||
while not condition():
|
||
check(time.monotonic() < deadline, message)
|
||
time.sleep(step)
|