Files
mtusi2026lab4/student-tests/filegen.py
T
2026-10-22 17:27:32 +03:00

200 lines
11 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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)