Re-attach to pid when using --client. Fixes microsoft/ptvsd#1817

Author: fabioz

src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_cython.c

@@ -6,7 +6,7 @@ from __future__ import print_function
 # DO NOT edit manually!
 import sys
 from _pydevd_bundle.pydevd_constants import (STATE_RUN, PYTHON_SUSPEND, IS_JYTHON,
-    USE_CUSTOM_SYS_CURRENT_FRAMES, USE_CUSTOM_SYS_CURRENT_FRAMES_MAP, ForkSafeLock)
+    USE_CUSTOM_SYS_CURRENT_FRAMES, USE_CUSTOM_SYS_CURRENT_FRAMES_MAP, SUPPORT_GEVENT, ForkSafeLock)
 from _pydev_bundle import pydev_log
 # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated)
 pydev_log.debug("Using Cython speedups")
@@ -134,7 +134,21 @@ cdef class PyDBAdditionalThreadInfo:
         '''
         # sys._current_frames(): dictionary with thread id -> topmost frame
         current_frames = _current_frames()
-        return current_frames.get(thread.ident)
+        topmost_frame = current_frames.get(thread.ident)
+        if topmost_frame is None:
+            # Note: this is expected for dummy threads (so, getting the topmost frame should be
+            # treated as optional).
+            pydev_log.info(
+                'Unable to get topmost frame for thread: %s, thread.ident: %s, id(thread): %s\nCurrent frames: %s.\n'
+                'GEVENT_SUPPORT: %s',
+                thread,
+                thread.ident,
+                id(thread),
+                current_frames,
+                SUPPORT_GEVENT,
+            )
+
+        return topmost_frame
 
     def __str__(self):
         return 'State:%s Stop:%s Cmd: %s Kill:%s' % (
@@ -1206,7 +1220,7 @@ def fix_top_level_trace_and_get_trace_func(py_db, frame):
             return f_trace, False
 
     thread_tracer = additional_info.thread_tracer
-    if thread_tracer is None:
+    if thread_tracer is None or thread_tracer._args[0] is not py_db:
         thread_tracer = ThreadTracer(args)
         additional_info.thread_tracer = thread_tracer
 

src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_cython.pyx

@@ -181,7 +181,7 @@ def fix_top_level_trace_and_get_trace_func(py_db, frame):
             return f_trace, False
 
     thread_tracer = additional_info.thread_tracer
-    if thread_tracer is None:
+    if thread_tracer is None or thread_tracer._args[0] is not py_db:
         thread_tracer = ThreadTracer(args)
         additional_info.thread_tracer = thread_tracer
 

src/debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_trace_dispatch_regular.py

@@ -63,6 +63,12 @@ def on_critical(msg):
         from debugpy.common import log
         from debugpy.server import options
 
+        import pydevd
+
+        py_db = pydevd.get_global_debugger()
+        if py_db is not None:
+            py_db.dispose_and_kill_all_pydevd_threads(wait=False)
+
         if log_dir is not None:
             log.log_dir = log_dir
         options.client = client

src/debugpy/server/attach_pid_injected.py

@@ -276,7 +276,7 @@ def attach_to_pid():
     assert os.path.exists(attach_pid_injected_dirname)
 
     log_dir = (log.log_dir or "").replace("\\", "/")
-    encode = lambda s: list(bytearray(s.encode("utf-8")))
+    encode = lambda s: list(bytearray(s.encode("utf-8"))) if s is not None else None
     setup = {
         "script": encode(attach_pid_injected_dirname),
         "host": encode(options.host),
@@ -289,7 +289,7 @@ def attach_to_pid():
     python_code = """
 import sys;
 import codecs;
-decode = lambda s: codecs.utf_8_decode(bytearray(s))[0];
+decode = lambda s: codecs.utf_8_decode(bytearray(s))[0] if s is not None else None;
 script_path = decode({script});
 sys.path.insert(0, script_path);
 import attach_pid_injected;

src/debugpy/server/cli.py

@@ -796,14 +796,17 @@ def wait_for_exit(self):
             finally:
                 watchdog.unregister_spawn(self.debuggee.pid, self.debuggee_id)
 
-        self.timeline.wait_until_realized(timeline.Event("terminated"))
+        self.wait_for_terminated()
 
         # FIXME: "exited" event is not properly reported in attach scenarios at the
         # moment, so the exit code is only checked if it's present.
         if self.debuggee is not None and self.exit_code is not None:
             assert self.debuggee.returncode == self.exit_code
         return self.exit_code
 
+    def wait_for_terminated(self):
+        self.timeline.wait_until_realized(timeline.Event("terminated"))
+
     def captured_stdout(self, encoding=None):
         assert self.debuggee is not None
         return self.captured_output.stdout(encoding)
@@ -819,7 +822,7 @@ def disconnect(self, force=False):
         try:
             if not force:
                 self.request("disconnect")
-                self.timeline.wait_until_realized(timeline.Event("terminated"))
+                self.wait_for_terminated()
         except messaging.JsonIOError:
             pass
         finally:

tests/debug/session.py

@@ -139,7 +139,7 @@ def code_to_debug():
 
 
 @pytest.mark.parametrize("pid_type", ["int", "str"])
-def test_attach_by_pid(pyfile, target, pid_type):
+def test_attach_by_pid_client(pyfile, target, pid_type):
     @pyfile
     def code_to_debug():
         import debuggee
@@ -148,40 +148,54 @@ def code_to_debug():
         debuggee.setup()
 
         def do_something(i):
-            time.sleep(0.1)
+            time.sleep(0.2)
             proceed = True
             print(i)  # @bp
             return proceed
 
-        for i in range(100):
+        for i in range(500):
             if not do_something(i):
                 break
 
-    with debug.Session() as session:
+    def before_request(command, arguments):
+        if command == "attach":
+            assert isinstance(arguments["processId"], int)
+            if pid_type == "str":
+                arguments["processId"] = str(arguments["processId"])
+
+    session1 = debug.Session()
+
+    session1.before_request = before_request
+    session1.config["redirectOutput"] = True
+
+    session1.captured_output = set()
+    session1.expected_exit_code = None  # not expected to exit on disconnect
+
+    with session1.attach_by_pid(target(code_to_debug), wait=False):
+        session1.set_breakpoints(code_to_debug, all)
 
-        def before_request(command, arguments):
-            if command == "attach":
-                assert isinstance(arguments["processId"], int)
-                if pid_type == "str":
-                    arguments["processId"] = str(arguments["processId"])
+    session1.wait_for_stop(expected_frames=[some.dap.frame(code_to_debug, "bp")])
 
-        session.before_request = before_request
-        session.config["redirectOutput"] = True
+    pid = session1.config["processId"]
 
-        with session.attach_by_pid(target(code_to_debug), wait=False):
-            session.set_breakpoints(code_to_debug, all)
+    # Note: don't call session1.disconnect because it'd deadlock in channel.close()
+    # (because the fd is in a read() in a different thread, we can't call close() on it).
+    session1.request("disconnect")
+    session1.wait_for_terminated()
 
-        stop = session.wait_for_stop(
+    with debug.Session() as session2:
+        with session2.attach_by_pid(pid, wait=False):
+            session2.set_breakpoints(code_to_debug, all)
+
+        stop = session2.wait_for_stop(
             expected_frames=[some.dap.frame(code_to_debug, "bp")]
         )
 
         # Remove breakpoint and continue.
-        session.request(
+        session2.set_breakpoints(code_to_debug, [])
+        session2.request(
             "setExpression",
             {"frameId": stop.frame_id, "expression": "proceed", "value": "False"},
         )
-        session.set_breakpoints(code_to_debug, [])
-        session.request_continue()
-        session.wait_for_next_event(
-            "output", some.dict.containing({"category": "stdout"})
-        )
+        session2.scratchpad["exit"] = True
+        session2.request_continue()