forked from mtusi2026/mtusi2026lab4
200 lines
11 KiB
Python
200 lines
11 KiB
Python
"""lab4: тестовые картинки и низкоуровневая загрузка — только стандартная библиотека Python.
|
||
|
||
- png(): настоящий PNG любого размера (шум не сжимается — так получаются файлы на 9 МБ);
|
||
- bomb_png(): «бомба» — файл ~150 КБ, внутри 42 млн пикселей (больше лимита 40 млн);
|
||
- SAMPLE_JPEG: синтетический JPEG 48×32 (781 байт), создан для курса программно;
|
||
- 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, 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==")
|
||
|
||
|
||
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 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):
|
||
"""Загрузить файл; пока S3 только запускается (503) — повторять до seconds. Возвращает ответ 201."""
|
||
path = f"/api/v1/chats/{chat['id']}/attachments?filename={name}"
|
||
deadline = time.monotonic() + seconds
|
||
while True:
|
||
reply = api.call("POST", path, [201, 503], actor=actor, raw=data or SAMPLE_PNG,
|
||
headers={"Content-Type": "image/png"}, schema="Attachment")
|
||
if reply["status"] == 201:
|
||
return reply
|
||
check(time.monotonic() < deadline, f"S3 is not ready for uploads after {seconds} s")
|
||
time.sleep(1)
|
||
|
||
|
||
# ---------- внутри стенда ----------
|
||
|
||
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)
|