Drop debugger path and duplicate func from rebasing

tractor/_spawn.py

@@ -25,10 +25,7 @@ from . import _forkserver_override
 from ._state import (
     current_actor,
     is_main_process,
-    is_root_process,
-    _runtime_vars,
 )
-from ._debug import _global_actor_in_debug
 
 from .log import get_logger
 from ._portal import Portal
@@ -155,27 +152,6 @@ async def cancel_on_completion(
         # cancel the process now that we have a final result
         await portal.cancel_actor()
 
-async def do_hard_kill(
-    proc: trio.Process,
-
-) -> None:
-    # NOTE: this timeout used to do nothing since we were shielding
-    # the ``.wait()`` inside ``new_proc()`` which will pretty much
-    # never release until the process exits, now it acts as
-    # a hard-kill time ultimatum.
-    with trio.move_on_after(3) as cs:
-
-        # NOTE: This ``__aexit__()`` shields internally.
-        async with proc:  # calls ``trio.Process.aclose()``
-            log.debug(f"Terminating {proc}")
-
-    if cs.cancelled_caught:
-        # XXX: should pretty much never get here unless we have
-        # to move the bits from ``proc.__aexit__()`` out and
-        # into here.
-        log.critical(f"HARD KILLING {proc}")
-        proc.kill()
-
 
 async def do_hard_kill(
     proc: trio.Process,
@@ -237,39 +213,6 @@ async def spawn_subactor(
         # to avoid killing the process too early
         # since trio does this internally on ``__aexit__()``
 
-        # if (
-        #     is_root_process()
-
-        #     # XXX: basically the pre-closing of stdstreams in a
-        #     # root-processe's ``trio.Process.aclose()`` can clobber
-        #     # any existing debugger session so we avoid
-        #     and _runtime_vars['_debug_mode']
-        #     and _global_actor_in_debug is not None
-        # ):
-        #     # XXX: this is ``trio.Process.aclose()`` MINUS the
-        #     # std-streams pre-closing steps inside ``proc.__aexit__()``
-        #     # (see below) which incluses a ``Process.kill()`` call
-
-        #     log.error(
-        #         "Root process tty is locked in debug mode by "
-        #         f"{_global_actor_in_debug}. If the console is hanging, you "
-        #         "may need to trigger a KBI to kill any "
-        #         "not-fully-initialized" " subprocesses and allow errors "
-        #         "from `trio` to propagate"
-        #     )
-        #     try:
-        #         # one more graceful wait try can can be cancelled by KBI
-        #         # sent by user.
-        #         await proc.wait()
-
-        #     finally:
-        #         if proc.returncode is None:
-        #             # with trio.CancelScope(shield=True):
-        #             #     await proc.wait()
-
-        #             await do_hard_kill(proc)
-        # else:
-
         await do_hard_kill(proc)