лр7: Docker-прогон, evidence, исправления

This commit is contained in:
kalibr456
2026-11-07 20:17:11 +03:00
parent 20afc2c790
commit cb38fd5231
249 changed files with 114500 additions and 82 deletions
+211
View File
@@ -0,0 +1,211 @@
"""Преобразование изображения, pipeline_version=1. Запускается worker'ом ОТДЕЛЬНЫМ процессом с лимитами.
python imaging.py <source> <out_dir> <content_type> <max_pixels>
Почему отдельный процесс: декодер Pillow работает в C, его нельзя прервать изнутри Python и нельзя
ограничить по памяти отдельно от остального worker. Процесс сам ставит себе RLIMIT_AS (память,
IMAGING_MEMORY_MB), RLIMIT_CPU (процессорное время) и RLIMIT_FSIZE до импорта Pillow, а worker
убивает его по таймауту JOB_TIMEOUT_SECONDS.
Падение, зависание или нехватка памяти здесь не роняют worker и не ломают подключение к брокеру.
Результат: файлы thumbnail.jpg, crop.jpg, optimized.webp в out_dir и одна строка JSON в stdout.
Код выхода: 0 — успех; 3 — невалидное изображение; 4 — слишком много пикселей; 5 — не хватило памяти;
прочее (в том числе убит сигналом) — неожиданная ошибка, worker считает её временной.
Правила вариантов (contracts/README.md):
- thumbnail: JPEG, вписан в 256x256 с сохранением пропорций, без увеличения, размеры округляются вниз
(минимум 1 px), EXIF orientation применяется, прозрачность накладывается на белый фон. 320x200 -> 256x160.
- crop: JPEG 128x128, центрированный квадрат (маленькие исходники увеличиваются).
- optimized: WebP, вписан в 1280x1280 без увеличения, quality=80, method=4; прозрачность сохраняется.
Во всех вариантах нет EXIF/XMP/комментариев: в save() передаётся только ICC-профиль (цвет), остальное
отбрасывается. Pillow при одинаковой версии даёт побайтно одинаковый результат, поэтому повтор job
пишет в те же ключи S3 те же байты.
"""
import json
import os
import resource
import sys
import time
def apply_limits() -> None:
"""Лимиты на себя, ДО импорта Pillow: память (RLIMIT_AS), CPU, размер записываемых файлов."""
memory = int(os.environ.get("IMAGING_MEMORY_MB", "640")) * 1024 * 1024
cpu = int(os.environ.get("IMAGING_CPU_SECONDS", "60"))
resource.setrlimit(resource.RLIMIT_AS, (memory, memory))
resource.setrlimit(resource.RLIMIT_CPU, (cpu, cpu + 5))
resource.setrlimit(resource.RLIMIT_FSIZE, (64 * 1024 * 1024, 64 * 1024 * 1024))
if __name__ == "__main__":
apply_limits()
from PIL import Image # noqa: E402 — после apply_limits: память декодера тоже под лимитом
PIPELINE_VERSION = 1
THUMB_BOX = 256
CROP_SIZE = 128
OPTIMIZED_BOX = 1280
THUMB_QUALITY = 85
CROP_QUALITY = 85
WEBP_QUALITY = 80
WEBP_METHOD = 4
EXIT_INVALID = 3
EXIT_TOO_LARGE = 4
EXIT_MEMORY = 5
FORMATS = {"image/png": "PNG", "image/jpeg": "JPEG"}
# EXIF orientation -> преобразование (как в PIL.ImageOps.exif_transpose)
ORIENTATION = {
2: [Image.Transpose.FLIP_LEFT_RIGHT],
3: [Image.Transpose.ROTATE_180],
4: [Image.Transpose.FLIP_TOP_BOTTOM],
5: [Image.Transpose.TRANSPOSE],
6: [Image.Transpose.ROTATE_270],
7: [Image.Transpose.TRANSVERSE],
8: [Image.Transpose.ROTATE_90],
}
class TooLarge(Exception):
pass
def fit(width: int, height: int, box: int) -> tuple[int, int]:
"""Вписать в box x box без увеличения; размеры вниз, минимум 1 px. Целочисленно, без float."""
if width <= box and height <= box:
return width, height
if width >= height:
return box, max(1, height * box // width)
return max(1, width * box // height), box
def orientation_of(image: Image.Image) -> int:
try:
value = image.getexif().get(0x0112, 1)
except Exception: # noqa: BLE001 — битый EXIF не делает картинку невалидной, ориентацию не трогаем
return 1
return value if value in ORIENTATION else 1
def normalize(image: Image.Image) -> Image.Image:
"""Любой режим PNG/JPEG -> L, RGB или RGBA (RGBA только если есть прозрачность)."""
mode = image.mode
transparent = "transparency" in image.info
if mode in ("I;16", "I;16B", "I;16L", "I"):
image = image.convert("I").point(lambda value: value * (1 / 256)).convert("L")
mode = "L"
if mode == "1":
return image.convert("L")
if mode in ("P", "PA"):
return image.convert("RGBA" if transparent or mode == "PA" else "RGB")
if mode in ("LA", "La", "RGBa"):
return image.convert("RGBA")
if mode in ("L", "RGB") and transparent:
return image.convert("RGBA")
if mode in ("L", "RGB", "RGBA"):
return image
return image.convert("RGB") # CMYK, YCbCr, LAB, ...
def on_white(image: Image.Image) -> Image.Image:
"""Прозрачность -> белый фон (для JPEG)."""
if image.mode != "RGBA":
return image
background = Image.new("RGB", image.size, (255, 255, 255))
background.paste(image, mask=image.getchannel("A"))
return background
def process(source: str, out_dir: str, content_type: str, max_pixels: int) -> dict:
Image.MAX_IMAGE_PIXELS = max_pixels
# lab7 (скан зависимостей): декодируются только PNG/JPEG — остальные плагины Pillow (TIFF, GIF, PDF, EPS, BMP,
# MSP...) недостижимы, даже если в staging попал бы файл другого формата.
with Image.open(source, formats=("PNG", "JPEG")) as image:
if image.format != FORMATS.get(content_type):
raise ValueError("format does not match stored content type")
width, height = image.size
if width * height > max_pixels:
raise TooLarge()
orientation = orientation_of(image)
icc = image.info.get("icc_profile")
swap = orientation in (5, 6, 7, 8)
oriented = (height, width) if swap else (width, height)
# Сначала уменьшаем до optimized (<= 1280), потом поворачиваем: квадратные рамки 1280/256/128
# не зависят от поворота, а поворот маленькой картинки дешевле, чем копия 40-мегапиксельной.
target = fit(*oriented, OPTIMIZED_BOX)
stored_target = (target[1], target[0]) if swap else target
if image.format == "JPEG":
image.draft(None, stored_target) # декодирование сразу в масштабе 1/2..1/8, если хватает
image.load()
work = normalize(image)
if work.size != stored_target:
work = work.resize(stored_target, Image.Resampling.LANCZOS, reducing_gap=3.0)
elif work is image:
work = work.copy()
for step in ORIENTATION.get(orientation, []):
work = work.transpose(step)
extra = {"icc_profile": icc} if icc else {}
results = []
optimized = work if work.mode != "L" else work.convert("RGB")
path = os.path.join(out_dir, "optimized.webp")
optimized.save(path, format="WEBP", quality=WEBP_QUALITY, method=WEBP_METHOD, **extra)
results.append({"name": "optimized", "content_type": "image/webp", "width": optimized.width,
"height": optimized.height, "file": "optimized.webp"})
thumb_size = fit(*oriented, THUMB_BOX) # от размеров ИСХОДНИКА, а не промежуточной копии
thumb = work if work.size == thumb_size else work.resize(thumb_size, Image.Resampling.LANCZOS)
thumb = on_white(thumb)
path = os.path.join(out_dir, "thumbnail.jpg")
thumb.save(path, format="JPEG", quality=THUMB_QUALITY, optimize=True, **extra)
results.append({"name": "thumbnail", "content_type": "image/jpeg", "width": thumb.width,
"height": thumb.height, "file": "thumbnail.jpg"})
side = min(work.size)
left, top = (work.width - side) // 2, (work.height - side) // 2
crop = work.crop((left, top, left + side, top + side))
crop = on_white(crop.resize((CROP_SIZE, CROP_SIZE), Image.Resampling.LANCZOS))
path = os.path.join(out_dir, "crop.jpg")
crop.save(path, format="JPEG", quality=CROP_QUALITY, optimize=True, **extra)
results.append({"name": "crop", "content_type": "image/jpeg", "width": CROP_SIZE, "height": CROP_SIZE,
"file": "crop.jpg"})
return {"pipeline_version": PIPELINE_VERSION, "source": {"width": width, "height": height,
"orientation": orientation}, "variants": results}
def injected_fault() -> None:
"""Учебные сбои (FAULT_IMAGING задаёт worker, только при FAULT_INJECTION=1)."""
fault = os.environ.get("FAULT_IMAGING", "")
if fault == "hang":
time.sleep(3600)
elif fault == "invalid":
raise ValueError("injected invalid image")
elif fault == "oom":
blocks = []
while True:
blocks.append(bytearray(64 * 1024 * 1024))
def main() -> int:
source, out_dir, content_type, max_pixels = sys.argv[1], sys.argv[2], sys.argv[3], int(sys.argv[4])
try:
injected_fault()
result = process(source, out_dir, content_type, max_pixels)
except (TooLarge, Image.DecompressionBombError):
return EXIT_TOO_LARGE
except MemoryError:
return EXIT_MEMORY
except (OSError, SyntaxError, ValueError, IndexError, TypeError, EOFError, Image.UnidentifiedImageError):
# Pillow сообщает о битом файле разными исключениями; подробности не нужны ни клиенту, ни логу.
return EXIT_INVALID
print(json.dumps(result), flush=True)
return 0
if __name__ == "__main__":
sys.exit(main())