forked from mtusi2026/mtusi2026lab5
216 lines
9.0 KiB
Python
216 lines
9.0 KiB
Python
from __future__ import annotations
|
|
"""Общий HTTP-клиент для собственных тестов (только стандартная библиотека)."""
|
|
import base64
|
|
import json
|
|
import urllib.error
|
|
import urllib.request
|
|
import uuid
|
|
|
|
PASSWORD = "Test-password-" + uuid.uuid4().hex[:8]
|
|
|
|
|
|
class Api:
|
|
def __init__(self, base: str):
|
|
self.base = base.rstrip("/")
|
|
|
|
def raw(self, method, path, data=None, headers=None, timeout=10):
|
|
req = urllib.request.Request(self.base + path, data=data, headers=headers or {}, method=method)
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=timeout) as r:
|
|
return r.status, r.read(), r.headers
|
|
except urllib.error.HTTPError as e:
|
|
return e.code, e.read(), e.headers
|
|
|
|
def call(self, method, path, body=None, token=None, headers=None, timeout=10):
|
|
h = dict(headers or {})
|
|
data = None
|
|
if body is not None:
|
|
data = json.dumps(body, ensure_ascii=False).encode()
|
|
h["Content-Type"] = "application/json"
|
|
if token:
|
|
h["Authorization"] = "Bearer " + token
|
|
# С lab3 POST сообщения требует Idempotency-Key; если тест не задал свой — новый ключ.
|
|
if method == "POST" and path.split("?")[0].endswith("/messages"):
|
|
h.setdefault("Idempotency-Key", uuid.uuid4().hex)
|
|
st, raw, rh = self.raw(method, path, data, h, timeout=timeout)
|
|
try:
|
|
return st, json.loads(raw or b"null"), rh
|
|
except ValueError:
|
|
return st, None, rh
|
|
|
|
def register(self, prefix: str, password: str = PASSWORD) -> dict:
|
|
name = (prefix + "_" + uuid.uuid4().hex[:10])[:32]
|
|
st, user, _ = self.call("POST", "/api/v1/users",
|
|
{"username": name, "display_name": prefix, "password": password})
|
|
assert st == 201, f"register {name}: {st} {user}"
|
|
user["password"] = password
|
|
return user
|
|
|
|
def login(self, username: str, password: str):
|
|
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
|
|
st, body, rh = self.call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
|
|
return st, body, rh
|
|
|
|
def new_user(self, prefix: str) -> dict:
|
|
user = self.register(prefix)
|
|
st, sess, _ = self.login(user["username"], user["password"])
|
|
assert st == 201, f"login: {st}"
|
|
user["token"] = sess["token"]
|
|
return user
|
|
|
|
|
|
class Report:
|
|
def __init__(self):
|
|
self.passed = self.failed = 0
|
|
|
|
def check(self, cond, name):
|
|
if cond:
|
|
self.passed += 1
|
|
print(f" ok - {name}")
|
|
else:
|
|
self.failed += 1
|
|
print(f" FAIL - {name}")
|
|
|
|
def finish(self):
|
|
print(f"\n{self.passed} passed, {self.failed} failed")
|
|
raise SystemExit(1 if self.failed else 0)
|
|
|
|
|
|
# ---------------------------------------------------------------- lab4: файлы
|
|
import hashlib
|
|
import os
|
|
import re
|
|
import select
|
|
import socket
|
|
import struct
|
|
import subprocess
|
|
import zlib
|
|
from pathlib import Path
|
|
from urllib.parse import urlparse
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
FIXTURES = Path(__file__).resolve().parent / "fixtures"
|
|
SAMPLE_PNG = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes()
|
|
SAMPLE_JPG = (FIXTURES / "sample.jpg").read_bytes()
|
|
COMPOSE = ["docker", "compose", "--env-file", ".env"]
|
|
|
|
|
|
def sha256(data: bytes) -> str:
|
|
return hashlib.sha256(data).hexdigest()
|
|
|
|
|
|
def make_png(width: int, height: int, *, noise: bool = False, color_type: int = 2,
|
|
rows: bytes | None = None) -> bytes:
|
|
"""Синтетический PNG только средствами stdlib.
|
|
noise=True — случайные пиксели (почти не сжимаются: так получаем файл нужного размера).
|
|
rows — готовые распакованные данные (для «бомб» и битых файлов)."""
|
|
channels = {0: 1, 2: 3, 6: 4}[color_type]
|
|
if rows is None:
|
|
line = width * channels
|
|
rows = b"".join(b"\x00" + (os.urandom(line) if noise else bytes(line)) for _ in range(height))
|
|
|
|
def chunk(kind: bytes, data: bytes) -> bytes:
|
|
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
|
|
|
|
ihdr = struct.pack(">IIBBBBB", width, height, 8, color_type, 0, 0, 0)
|
|
return (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr)
|
|
+ chunk(b"IDAT", zlib.compress(rows, 1 if noise else 9)) + chunk(b"IEND", b""))
|
|
|
|
|
|
def upload(api, token: str, chat_id: str, data: bytes, filename: str = "image.png",
|
|
content_type: str = "image/png", headers: dict | None = None, timeout: int = 60):
|
|
from urllib.parse import quote
|
|
h = {"Authorization": "Bearer " + token, "Content-Type": content_type, **(headers or {})}
|
|
path = f"/api/v1/chats/{chat_id}/attachments?filename={quote(filename, safe='')}"
|
|
st, raw, rh = api.raw("POST", path, data, h, timeout=timeout)
|
|
try:
|
|
body = json.loads(raw or b"null")
|
|
except ValueError:
|
|
body = None
|
|
return st, body, rh
|
|
|
|
|
|
def wait_ready(api, token: str, attachment_id: str, seconds: float = 90) -> dict:
|
|
"""lab5: upload отвечает 202 queued; ждём, пока worker доведёт до ready/failed."""
|
|
import time
|
|
deadline = time.monotonic() + seconds
|
|
att = {}
|
|
while time.monotonic() < deadline:
|
|
st, att, _ = api.call("GET", f"/api/v1/attachments/{attachment_id}", token=token)
|
|
if st == 200 and att["status"] in ("ready", "failed"):
|
|
return att
|
|
time.sleep(0.3)
|
|
return att or {}
|
|
|
|
|
|
def raw_http(base: str, method: str, path: str, headers: dict, chunks=(), chunked: bool = False,
|
|
close_after_send: bool = False, timeout: float = 30):
|
|
"""HTTP/1.1 «руками» через сокет — для сценариев, которые urllib не умеет:
|
|
заявить Content-Length и не прислать тело, прислать chunked больше лимита,
|
|
оборвать загрузку на середине. Пока шлём тело, следим, не ответил ли сервер
|
|
раньше (413 до конца тела) — тогда прекращаем отправку и читаем ответ.
|
|
Возвращает (status | None, body_bytes)."""
|
|
u = urlparse(base)
|
|
sock = socket.create_connection((u.hostname, u.port or 80), timeout=timeout)
|
|
try:
|
|
lines = [f"{method} {path} HTTP/1.1", f"Host: {u.hostname}:{u.port or 80}", "Connection: close"]
|
|
lines += [f"{k}: {v}" for k, v in headers.items()]
|
|
if chunked:
|
|
lines.append("Transfer-Encoding: chunked")
|
|
sock.sendall(("\r\n".join(lines) + "\r\n\r\n").encode("latin-1"))
|
|
for part in chunks:
|
|
ready, _, _ = select.select([sock], [], [], 0)
|
|
if ready:
|
|
break # сервер уже ответил — дальше не шлём
|
|
try:
|
|
sock.sendall(f"{len(part):x}\r\n".encode() + part + b"\r\n" if chunked else part)
|
|
except (BrokenPipeError, ConnectionResetError):
|
|
break
|
|
else:
|
|
if chunked and not close_after_send:
|
|
try:
|
|
sock.sendall(b"0\r\n\r\n")
|
|
except OSError:
|
|
pass
|
|
if close_after_send:
|
|
return None, b"" # обрыв загрузки: ответ не ждём
|
|
data = b""
|
|
try:
|
|
while True:
|
|
piece = sock.recv(65536)
|
|
if not piece:
|
|
break
|
|
data += piece
|
|
except (ConnectionResetError, socket.timeout):
|
|
pass
|
|
finally:
|
|
sock.close()
|
|
m = re.match(rb"HTTP/1\.[01] (\d{3})", data)
|
|
return (int(m.group(1)) if m else None), data.split(b"\r\n\r\n", 1)[-1]
|
|
|
|
|
|
def compose(*args: str, check: bool = True) -> str:
|
|
out = subprocess.run(COMPOSE + list(args), cwd=ROOT, capture_output=True, text=True)
|
|
if check and out.returncode != 0:
|
|
raise RuntimeError(f"docker compose {' '.join(args)} failed: {out.stderr.strip()[-300:]}")
|
|
return out.stdout
|
|
|
|
|
|
def tool(*args: str) -> dict:
|
|
"""python -m app.tools … внутри контейнера api → последняя строка JSON."""
|
|
out = compose("exec", "-T", "api", "python", "-m", "app.tools", *args)
|
|
return json.loads(out.strip().splitlines()[-1])
|
|
|
|
|
|
def janitor(*args: str, attempts: int = 10) -> dict:
|
|
"""Один проход очистки внутри api. Если advisory lock занят фоновым
|
|
проходом другой реплики — повторяем."""
|
|
import time
|
|
for _ in range(attempts):
|
|
out = compose("exec", "-T", "api", "python", "-m", "app.janitor", "--once", *args)
|
|
stats = json.loads(out.strip().splitlines()[-1])
|
|
if stats.get("locked"):
|
|
return stats
|
|
time.sleep(1)
|
|
raise RuntimeError("janitor lock is busy")
|