222 lines
8.7 KiB
Python
222 lines
8.7 KiB
Python
"""Cancellation interrupts idle I/O and uses an independent control request."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import json
|
|
import socket
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from threading import Event, Thread, get_ident
|
|
from uuid import uuid4
|
|
|
|
import httpx
|
|
import pytest
|
|
|
|
from doctor_workstation.services.api_client import ApiClient
|
|
from doctor_workstation.services.repository import RemoteDoctorRepository
|
|
|
|
|
|
@pytest.mark.parametrize("stage", ["headers", "body"])
|
|
def test_cancel_interrupts_idle_read_and_cleans_up_on_owning_loop(stage):
|
|
entered, cancelled = Event(), Event()
|
|
body_threads, closed_threads = [], []
|
|
|
|
class IdleStream(httpx.AsyncByteStream):
|
|
async def __aiter__(self):
|
|
body_threads.append(get_ident())
|
|
entered.set()
|
|
await asyncio.sleep(30)
|
|
yield b"event: done\ndata: {}\n\n"
|
|
|
|
async def aclose(self):
|
|
closed_threads.append(get_ident())
|
|
|
|
async def handler(request):
|
|
if stage == "headers":
|
|
entered.set()
|
|
await asyncio.sleep(30)
|
|
return httpx.Response(200, headers={"content-type": "text/event-stream"}, stream=IdleStream())
|
|
|
|
client = ApiClient("https://example.test", transport=httpx.MockTransport(handler))
|
|
with ThreadPoolExecutor(max_workers=1) as executor:
|
|
future = executor.submit(lambda: list(client.post_event_stream(
|
|
"tcm.diagnosis/aiAssistantStream", {"id": 501}, cancelled=cancelled.is_set,
|
|
)))
|
|
assert entered.wait(2)
|
|
cancelled.set()
|
|
assert future.result(timeout=0.8) == []
|
|
if stage == "body":
|
|
assert body_threads == closed_threads
|
|
client.close()
|
|
|
|
|
|
@pytest.mark.parametrize("headers_sent", [False, True])
|
|
def test_default_transport_closes_idle_local_socket_without_another_line(headers_sent):
|
|
entered, disconnected, cancelled = Event(), Event(), Event()
|
|
listener = socket.socket()
|
|
listener.bind(("127.0.0.1", 0))
|
|
listener.listen(1)
|
|
listener.settimeout(3)
|
|
|
|
def serve():
|
|
try:
|
|
connection, _ = listener.accept()
|
|
with connection:
|
|
connection.settimeout(3)
|
|
request = b""
|
|
while b"\r\n\r\n" not in request:
|
|
request += connection.recv(4096)
|
|
header, body = request.split(b"\r\n\r\n", 1)
|
|
length = next(int(line.split(b":", 1)[1]) for line in header.split(b"\r\n") if line.lower().startswith(b"content-length:"))
|
|
while len(body) < length:
|
|
body += connection.recv(4096)
|
|
if headers_sent:
|
|
connection.sendall(b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nConnection: close\r\n\r\n")
|
|
entered.set()
|
|
if connection.recv(1) == b"":
|
|
disconnected.set()
|
|
finally:
|
|
listener.close()
|
|
|
|
thread = Thread(target=serve, daemon=True)
|
|
thread.start()
|
|
with ApiClient(f"http://127.0.0.1:{listener.getsockname()[1]}") as client, ThreadPoolExecutor(max_workers=1) as executor:
|
|
future = executor.submit(lambda: list(client.post_event_stream(
|
|
"tcm.diagnosis/aiAssistantStream", {"id": 501}, cancelled=cancelled.is_set,
|
|
)))
|
|
try:
|
|
assert entered.wait(2)
|
|
cancelled.set()
|
|
assert future.result(timeout=0.8) == []
|
|
assert disconnected.wait(0.8)
|
|
finally:
|
|
cancelled.set()
|
|
thread.join(timeout=1)
|
|
assert not thread.is_alive()
|
|
|
|
|
|
def test_cancel_control_post_bypasses_busy_short_request_pool(monkeypatch):
|
|
from doctor_workstation.services import api_client as module
|
|
|
|
entered, release = Event(), Event()
|
|
created = []
|
|
|
|
class Client:
|
|
def __init__(self, **options):
|
|
created.append(self)
|
|
|
|
def request(self, *args, **kwargs):
|
|
entered.set()
|
|
assert release.wait(2)
|
|
return httpx.Response(200, json={"code": 1, "data": {}})
|
|
|
|
def post(self, url, **kwargs):
|
|
return httpx.Response(200, json={"code": 1, "data": {"cancel_requested": True}})
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, *args):
|
|
self.close()
|
|
|
|
monkeypatch.setattr(module.httpx, "Client", Client)
|
|
client = ApiClient("https://example.test", max_parallel_requests=1)
|
|
with ThreadPoolExecutor(max_workers=1) as executor:
|
|
future = executor.submit(client.get, "synthetic/busy")
|
|
try:
|
|
assert entered.wait(1)
|
|
assert client.post_independent("tcm.diagnosis/cancelAiAssistant", {"id": 501}) == {"cancel_requested": True}
|
|
assert len(created) == 2
|
|
finally:
|
|
release.set()
|
|
future.result(timeout=1)
|
|
client.close()
|
|
|
|
|
|
def test_stream_progress_and_cancel_preserve_same_request_identity():
|
|
requests = []
|
|
request_id = str(uuid4())
|
|
|
|
def handler(request):
|
|
requests.append(request)
|
|
if request.url.path.endswith("cancelAiAssistant"):
|
|
return httpx.Response(200, json={"code": 1, "data": {"cancel_requested": True, "upstream_stop_confirmed": False}})
|
|
return httpx.Response(200, headers={"content-type": "text/event-stream"}, text=(
|
|
'event: progress\ndata: {"phase":"attachments","items":[{"kind":"image","label":"图片附件1","status":"submitted"}],"attachment_count":1}\n\n'
|
|
'event: done\ndata: {}\n\n'
|
|
))
|
|
|
|
with ApiClient("https://example.test", transport=httpx.MockTransport(handler)) as client:
|
|
repository = RemoteDoctorRepository(client)
|
|
events = list(repository.stream_diagnosis_ai(501, "合成问题", request_id=request_id))
|
|
result = repository.cancel_diagnosis_ai(501, request_id)
|
|
assert events[0]["event"] == "progress" and events[0]["items"][0]["status"] == "submitted"
|
|
assert json.loads(requests[0].content)["request_id"] == request_id
|
|
assert json.loads(requests[1].content) == {"id": 501, "request_id": request_id}
|
|
assert result["cancel_requested"] and not result["upstream_stop_confirmed"]
|
|
|
|
|
|
def test_async_bridge_batches_thousands_of_frames_without_per_delta_tasks(monkeypatch):
|
|
from doctor_workstation.services import api_client as module
|
|
|
|
calls = {"tasks": 0, "loop_runs": 0}
|
|
new_event_loop = asyncio.new_event_loop
|
|
|
|
def counted_loop():
|
|
loop = new_event_loop()
|
|
create_task, run_forever = loop.create_task, loop.run_forever
|
|
|
|
def task(*args, **kwargs):
|
|
calls["tasks"] += 1
|
|
return create_task(*args, **kwargs)
|
|
|
|
def run():
|
|
calls["loop_runs"] += 1
|
|
return run_forever()
|
|
|
|
loop.create_task, loop.run_forever = task, run
|
|
return loop
|
|
|
|
monkeypatch.setattr(module.asyncio, "new_event_loop", counted_loop)
|
|
chunks = [f"片段{index}🩺" for index in range(6000)]
|
|
content = "".join("event: delta\ndata: " + json.dumps({"text": text}) + "\n\n" for text in chunks)
|
|
content += 'event: done\ndata: {}\n\n'
|
|
transport = httpx.MockTransport(lambda request: httpx.Response(
|
|
200, headers={"content-type": "text/event-stream"}, text=content,
|
|
))
|
|
with ApiClient("https://example.test", transport=transport) as client:
|
|
events = list(client.post_event_stream("synthetic/stream", {}, cancelled=lambda: False))
|
|
assert [event["data"]["text"] for event in events[:-1]] == chunks
|
|
assert events[-1]["event"] == "done"
|
|
assert calls["tasks"] <= 8
|
|
assert calls["loop_runs"] <= 40
|
|
|
|
|
|
@pytest.mark.parametrize("ending", ["eof", "error"])
|
|
def test_async_batch_drains_queued_tail_before_eof_or_error(ending):
|
|
class TailStream(httpx.AsyncByteStream):
|
|
async def __aiter__(self):
|
|
yield b'event: delta\ndata: {"text":"first"}\n\nevent: delta\ndata: {"text":"tail"}\n\n'
|
|
if ending == "error":
|
|
raise httpx.ReadError("synthetic read failure")
|
|
# A valid final SSE frame need not end with a blank line.
|
|
yield b'event: delta\ndata: {"text":"last"}'
|
|
|
|
transport = httpx.MockTransport(lambda request: httpx.Response(
|
|
200, headers={"content-type": "text/event-stream"}, stream=TailStream(),
|
|
))
|
|
with ApiClient("https://example.test", transport=transport) as client:
|
|
stream = client.post_event_stream("synthetic/stream", {}, cancelled=lambda: False)
|
|
assert next(stream)["data"]["text"] == "first"
|
|
assert next(stream)["data"]["text"] == "tail"
|
|
if ending == "error":
|
|
from doctor_workstation.core.errors import ApiTransportError
|
|
with pytest.raises(ApiTransportError, match="stream failed"):
|
|
next(stream)
|
|
else:
|
|
assert next(stream)["data"]["text"] == "last"
|
|
assert list(stream) == []
|