forcefully abort children of unclosed nurseries to avoid internalerror

Author: jakkdl

src/trio/_core/_run.py

@@ -2013,11 +2013,33 @@ def task_exited(self, task: Task, outcome: Outcome[object]) -> None:
                 lot.break_lot(task)
             del GLOBAL_PARKING_LOT_BREAKER[task]
 
-        if (
+        if task._child_nurseries:
+            # Forcefully abort any tasks spawned by the misnested nursery to
+            # avoid internal errors.
+            runner = GLOBAL_RUN_CONTEXT.runner
+            for nursery in task._child_nurseries:
+                nursery.cancel_scope.cancel()
+                for child in nursery._children:
+                    if child in runner.runq:
+                        runner.runq.remove(child)
+                        runner.tasks.remove(child)
+                nursery._children.clear()
+            try:
+                # Raise this, rather than just constructing it, to get a
+                # traceback frame included
+                raise RuntimeError(
+                    "Nursery stack corrupted: nurseries spawned by "
+                    f"{task!r} was still live when the task exited\n{MISNESTING_ADVICE}",
+                )
+            except RuntimeError as new_exc:
+                if isinstance(outcome, Error):
+                    new_exc.__context__ = outcome.error
+                outcome = Error(new_exc)
+        elif (
             task._cancel_status is not None
             and task._cancel_status.abandoned_by_misnesting
             and task._cancel_status.parent is None
-        ) or any(not nursery._closed for nursery in task._child_nurseries):
+        ):
             # The cancel scope surrounding this task's nursery was closed
             # before the task exited. Force the task to exit with an error,
             # since the error might not have been caught elsewhere. See the

src/trio/_core/_tests/test_run.py

@@ -861,7 +861,7 @@ async def inner_func() -> None:
         inner_nursery.start_soon(sleep, 1)
 
     with pytest.RaisesGroup(
-        pytest.RaisesExc(RuntimeError, match="Cancel scope stack corrupted")
+        pytest.RaisesExc(RuntimeError, match="Nursery stack corrupted")
     ):
         async with _core.open_nursery() as outer_nursery:
             inner_cm = _core.open_nursery()
@@ -874,20 +874,37 @@ async def asynccontextmanager_that_creates_a_nursery_internally() -> (
         AsyncGenerator[None]
     ):
         async with _core.open_nursery() as nursery:
-            nursery.start_soon(
-                print_sleep_print, "task_in_asynccontextmanager_nursery", 2.0
-            )
+            await nursery.start(started_sleeper)
+            nursery.start_soon(unstarted_task)
             yield
 
-    async def print_sleep_print(name: str, sleep_time: float) -> None:
-        await sleep(sleep_time)
+    async def started_sleeper(task_status: _core.TaskStatus[None]) -> None:
+        task_status.started()
+        await sleep_forever()
 
-    async with AsyncExitStack() as stack, _core.open_nursery() as nursery:
+    async def unstarted_task() -> None:
+        raise AssertionError("this should not even get a chance to run")
+
+    async with AsyncExitStack() as stack:
+        manager = _core.open_nursery()
+        nursery = await manager.__aenter__()
         # The asynccontextmanager is going to create a nursery that outlives this nursery!
         nursery.start_soon(
             stack.enter_async_context,
             asynccontextmanager_that_creates_a_nursery_internally(),
         )
+        with pytest.RaisesGroup(
+            pytest.RaisesExc(RuntimeError, match="Nursery stack corrupted")
+        ):
+            await manager.__aexit__(None, None, None)
+
+    # The outer nursery forcefully aborts the inner nursery and stops `unstarted_task`
+    # from ever being started.
+    with pytest.warns(
+        RuntimeWarning,
+        match="^coroutine 'test_asyncexitstack_nursery_misnest.<locals>.unstarted_task' was never awaited$",
+    ):
+        gc_collect_harder()
 
 
 @slow