kshitijk4poor
111d809562
The adapter's private thread-deadline helper was the ancestor of the unified deadline layer's run_bounded_async (#85147 was extracted from it, plus the caller-cancellation leak fix the original still lacked). Consolidate: the helper body becomes a thin wrapper mapping BoundedResult.timed_out back to the asyncio.TimeoutError its 9 call sites (the PTB retry ladder) expect. ~90 duplicated lines die, along with the adapter-local copies of the abandon-cleanup runner and the blocked-loop faulthandler diagnostics (both live in agent/deadline.py). Everything the call sites rely on is preserved by the unified layer: - thread-timer deadline that survives a blocked event loop (#63309) - abandonment of cancellation-shielded tasks (PTB/httpcore anyio init) - detached best-effort on_abandon cleanup (no httpx pool leak per retry) - off-loop stack dump when the loop never processes the expiry Plus one behavior IMPROVEMENT inherited from the shared copy: a caller cancelling the wrapper no longer leaks the inner task unobserved (the telegram original had that leak; the extraction fixed it). test_telegram_init_deadline.py: the #63309 diagnostics probe now pins the shared layer's dump hook (label "telegram-init") — same contract, new seam. Wedge + cleanup-crash tests pass unchanged.
112 lines
4.1 KiB
Python
112 lines
4.1 KiB
Python
import pytest
|
|
|
|
from gateway.config import PlatformConfig
|
|
from plugins.platforms.telegram import adapter as tg_adapter # noqa: E402
|
|
from plugins.platforms.telegram.adapter import TelegramAdapter # noqa: E402
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_await_with_thread_deadline_abandons_and_runs_cleanup_on_timeout():
|
|
"""A wedged awaitable must raise TimeoutError promptly AND trigger the
|
|
best-effort on_abandon cleanup (the httpx-pool-leak guard).
|
|
|
|
This exercises the REAL _await_with_thread_deadline (not a monkeypatched
|
|
stub), covering the abandonment + cleanup mechanism directly.
|
|
"""
|
|
import asyncio as _asyncio
|
|
import time as _time
|
|
|
|
cleanup_ran = _asyncio.Event()
|
|
|
|
async def _wedged():
|
|
# Swallows cancellation for a bounded window — long enough that the
|
|
# helper must return control BEFORE this finishes (proving it doesn't
|
|
# await cancellation, the #58236 shielded-scope behavior), but bounded
|
|
# so the abandoned task can't outlive the test and wedge teardown.
|
|
for _ in range(20):
|
|
try:
|
|
await _asyncio.sleep(0.05)
|
|
except _asyncio.CancelledError:
|
|
# Keep going despite cancellation, like the shielded scope.
|
|
pass
|
|
|
|
async def _cleanup():
|
|
cleanup_ran.set()
|
|
|
|
started = _time.monotonic()
|
|
with pytest.raises(_asyncio.TimeoutError):
|
|
await tg_adapter._await_with_thread_deadline(
|
|
_wedged(), timeout=0.2, on_abandon=_cleanup
|
|
)
|
|
elapsed = _time.monotonic() - started
|
|
|
|
# Returned control promptly — well before the wedged coroutine's ~1s span.
|
|
assert elapsed < 0.8
|
|
# The detached cleanup was scheduled; give the loop a tick to run it.
|
|
await _asyncio.wait_for(cleanup_ran.wait(), timeout=2.0)
|
|
assert cleanup_ran.is_set()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_await_with_thread_deadline_cleanup_error_is_swallowed():
|
|
"""A cleanup that raises must not surface as an unhandled task error."""
|
|
import asyncio as _asyncio
|
|
|
|
async def _wedged():
|
|
for _ in range(20):
|
|
try:
|
|
await _asyncio.sleep(0.05)
|
|
except _asyncio.CancelledError:
|
|
pass
|
|
|
|
def _boom():
|
|
raise RuntimeError("cleanup blew up")
|
|
|
|
# Must still raise TimeoutError (not the cleanup error) and not crash.
|
|
with pytest.raises(_asyncio.TimeoutError):
|
|
await tg_adapter._await_with_thread_deadline(
|
|
_wedged(), timeout=0.2, on_abandon=_boom
|
|
)
|
|
# Let the detached cleanup task run and be observed (no unraised error).
|
|
await _asyncio.sleep(0.05)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_blocked_loop_after_expiry_dumps_diagnostics(monkeypatch):
|
|
"""#63309: when the loop thread is stuck in a synchronous call, the expiry
|
|
callback never runs and every asyncio timeout goes silent. The off-loop
|
|
watchdog must detect that state and emit diagnostics from its own thread."""
|
|
import asyncio as _asyncio
|
|
import time as _time
|
|
|
|
from agent import deadline as _deadline
|
|
|
|
dumps = []
|
|
monkeypatch.setattr(
|
|
_deadline,
|
|
"_dump_blocked_loop_diagnostics",
|
|
lambda label, timeout_s: dumps.append((label, timeout_s)),
|
|
)
|
|
monkeypatch.setattr(_deadline, "_LOOP_BLOCKED_DUMP_GRACE_S", 0.15)
|
|
|
|
hung = _asyncio.get_running_loop().create_future() # never completes
|
|
task = _asyncio.ensure_future(
|
|
tg_adapter._await_with_thread_deadline(hung, timeout=0.05)
|
|
)
|
|
# Let the helper start its deadline + watchdog timers…
|
|
await _asyncio.sleep(0)
|
|
# …then block the event loop straight through deadline (0.05s) AND the
|
|
# watchdog grace (0.15s): call_soon_threadsafe stays queued, exactly like
|
|
# a sync call pinning the loop during Application.initialize().
|
|
# Margin matters: the watchdog thread only dumps if the loop is STILL
|
|
# blocked when it wakes, and thread wakeup lags under parallel-suite load.
|
|
# 0.2s (= deadline+grace exactly) flaked in a 40-worker full-suite run.
|
|
_time.sleep(1.0)
|
|
with pytest.raises(_asyncio.TimeoutError):
|
|
await task
|
|
|
|
assert dumps == [("telegram-init", 0.05)]
|
|
hung.cancel()
|
|
|
|
|