The pipeline now runs the guard first, so an anonymous upload with a too large Content-Length gets 401 with WWW-Authenticate, as the contract asks; the guard does not read the body, so 413 still comes before the first body byte for an authenticated client. The single request deadline cut slow but steady uploads and downloads: a client slower than about 1.3 MB/s could not move 10 MiB in 8 s. Each body chunk the application receives or sends now moves the deadline to min(now, start + moved / MIN_TRANSFER_RATE_BYTES) + REQUEST_TIMEOUT, 128 KiB/s by default, like mod_reqtimeout with a ceiling: a steady transfer lives as long as it moves, a stalled or crawling body is cut after the request timeout as before, and the work after the last body byte still gets at most the request timeout. The pipeline's own error responses bypass the pacing. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
147 lines
5.9 KiB
Python
147 lines
5.9 KiB
Python
import asyncio
|
|
from collections.abc import AsyncIterator, Callable
|
|
from contextlib import asynccontextmanager
|
|
|
|
from httpx import AsyncClient
|
|
|
|
from conftest import actor, keyed, make_chat, register, resolve, running_app, scalar
|
|
from fakes import MemoryObjectStorage
|
|
from messenger.attachments.application.ports import ObjectStorage
|
|
from messenger.messaging.application import handlers
|
|
from messenger.messaging.domain.events import MessagePosted
|
|
from messenger.shared.application.messagebus import EventBus
|
|
from pictures import SAMPLE, png
|
|
|
|
MARKER = "текст-который-не-должен-утечь-при-таймауте"
|
|
|
|
|
|
@asynccontextmanager
|
|
async def slow_post(delay: float) -> AsyncIterator[None]:
|
|
original: Callable = handlers.PostMessageHandler.__call__
|
|
|
|
async def stalled(self, command):
|
|
await asyncio.sleep(delay)
|
|
return await original(self, command)
|
|
|
|
handlers.PostMessageHandler.__call__ = stalled
|
|
try:
|
|
yield
|
|
finally:
|
|
handlers.PostMessageHandler.__call__ = original
|
|
|
|
|
|
async def post(client: AsyncClient, chat: dict, sender: dict, text: str):
|
|
return await client.post(
|
|
f"/api/v1/chats/{chat['id']}/messages", json={"text": text}, headers=keyed(sender)
|
|
)
|
|
|
|
|
|
async def prepared(client: AsyncClient) -> tuple[dict, dict]:
|
|
alice = await register(client, "alice")
|
|
return alice, await make_chat(client, alice)
|
|
|
|
|
|
async def test_timeout_returns_unavailable_error_body() -> None:
|
|
async with running_app(request_timeout_seconds=0.15) as client:
|
|
alice, chat = await prepared(client)
|
|
async with slow_post(1.0):
|
|
response = await post(client, chat, alice, "медленная запись")
|
|
assert response.status_code == 503
|
|
body = response.json()
|
|
assert body["error"]["code"] == "unavailable"
|
|
assert body["error"]["request_id"] == response.headers["X-Request-Id"]
|
|
|
|
|
|
async def test_timeout_does_not_break_following_requests() -> None:
|
|
async with running_app(request_timeout_seconds=0.15) as client:
|
|
alice, chat = await prepared(client)
|
|
async with slow_post(1.0):
|
|
assert (await post(client, chat, alice, "зависшая запись")).status_code == 503
|
|
assert (await post(client, chat, alice, "нормальная запись")).status_code == 201
|
|
assert (await client.get("/health/ready")).status_code == 200
|
|
|
|
|
|
async def test_timeout_is_logged_without_message_text(capsys) -> None:
|
|
async with running_app(request_timeout_seconds=0.15, log_level="INFO") as client:
|
|
alice, chat = await prepared(client)
|
|
async with slow_post(1.0):
|
|
assert (await post(client, chat, alice, MARKER)).status_code == 503
|
|
captured = capsys.readouterr()
|
|
assert "request.timeout" in captured.out
|
|
assert MARKER not in captured.out
|
|
assert MARKER not in captured.err
|
|
|
|
|
|
async def test_normal_request_is_not_affected_by_timeout() -> None:
|
|
async with running_app(request_timeout_seconds=5.0) as client:
|
|
alice, chat = await prepared(client)
|
|
assert (await post(client, chat, alice, "обычная запись")).status_code == 201
|
|
|
|
|
|
async def test_slow_event_handler_does_not_trigger_timeout() -> None:
|
|
async with running_app(request_timeout_seconds=0.3) as client:
|
|
alice, chat = await prepared(client)
|
|
blocked = asyncio.Event()
|
|
bus = await resolve(client, EventBus)
|
|
|
|
async def stall(_event: MessagePosted) -> None:
|
|
await blocked.wait()
|
|
|
|
bus.subscribe(MessagePosted, stall)
|
|
response = await post(client, chat, alice, "ответ не ждёт обработчик")
|
|
blocked.set()
|
|
assert response.status_code == 201
|
|
|
|
|
|
async def test_healthcheck_stays_fast(client: AsyncClient) -> None:
|
|
loop = asyncio.get_running_loop()
|
|
started = loop.time()
|
|
assert (await client.get("/health/live")).status_code == 200
|
|
assert loop.time() - started < 1.0
|
|
|
|
|
|
async def trickled(data: bytes, size: int, delay: float) -> AsyncIterator[bytes]:
|
|
for start in range(0, len(data), size):
|
|
await asyncio.sleep(delay)
|
|
yield data[start : start + size]
|
|
|
|
|
|
async def upload(client: AsyncClient, user: dict, chat: dict, body: AsyncIterator[bytes]):
|
|
return await client.post(
|
|
f"/api/v1/chats/{chat['id']}/attachments?filename=slow.png",
|
|
content=body,
|
|
headers={**actor(user), "Content-Type": "image/png"},
|
|
)
|
|
|
|
|
|
async def test_steady_slow_transfer_outlives_the_request_timeout() -> None:
|
|
picture = png(16, 16, size=1 << 20)
|
|
async with running_app(request_timeout_seconds=0.4, min_transfer_rate_bytes=16_384) as client:
|
|
alice, chat = await prepared(client)
|
|
loop = asyncio.get_running_loop()
|
|
started = loop.time()
|
|
uploaded = await upload(client, alice, chat, trickled(picture, 65_536, 0.1))
|
|
assert uploaded.status_code == 201, uploaded.text
|
|
assert loop.time() - started > 1.0
|
|
store = await resolve(client, ObjectStorage)
|
|
assert isinstance(store, MemoryObjectStorage)
|
|
store.delay = 0.1
|
|
started = loop.time()
|
|
content = await client.get(
|
|
f"/api/v1/attachments/{uploaded.json()['id']}/content", headers=actor(alice)
|
|
)
|
|
assert (content.status_code, content.content) == (200, picture)
|
|
assert loop.time() - started > 1.0
|
|
|
|
|
|
async def test_body_slower_than_the_minimal_rate_is_cut() -> None:
|
|
async with running_app(request_timeout_seconds=0.3, min_transfer_rate_bytes=1 << 20) as client:
|
|
alice, chat = await prepared(client)
|
|
before = await scalar("SELECT count(*) FROM attachments")
|
|
loop = asyncio.get_running_loop()
|
|
started = loop.time()
|
|
response = await upload(client, alice, chat, trickled(SAMPLE, 4_096, 0.1))
|
|
assert (response.status_code, response.json()["error"]["code"]) == (503, "unavailable")
|
|
assert loop.time() - started < 1.0
|
|
assert await scalar("SELECT count(*) FROM attachments") == before
|