Don't use pydevd_find_thread_by_id unless really needed. Fixes #1129

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

@@ -209,12 +209,13 @@ def request_stack(self, py_db, seq, thread_id, fmt=None, timeout=.5, start_frame
  else:
  py_db.post_internal_command(internal_get_thread_stack, '*')
 
- def request_exception_info_json(self, py_db, request, thread_id, max_frames):
+ def request_exception_info_json(self, py_db, request, thread_id, thread, max_frames):
  py_db.post_method_as_internal_command(
  thread_id,
  internal_get_exception_details_json,
  request,
  thread_id,
+ thread,
  max_frames,
  set_additional_thread_info=set_additional_thread_info,
  iter_visible_frames_info=py_db.cmd_factory._iter_visible_frames_info,

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

@@ -669,7 +669,7 @@ def do_it(self, dbg):
 
 def internal_step_in_thread(py_db, thread_id, cmd_id, set_additional_thread_info):
  thread_to_step = pydevd_find_thread_by_id(thread_id)
- if thread_to_step:
+ if thread_to_step is not None:
  info = set_additional_thread_info(thread_to_step)
  info.pydev_original_step_cmd = cmd_id
  info.pydev_step_cmd = cmd_id
@@ -682,7 +682,7 @@ def internal_step_in_thread(py_db, thread_id, cmd_id, set_additional_thread_info
 
 def internal_smart_step_into(py_db, thread_id, offset, child_offset, set_additional_thread_info):
  thread_to_step = pydevd_find_thread_by_id(thread_id)
- if thread_to_step:
+ if thread_to_step is not None:
  info = set_additional_thread_info(thread_to_step)
  info.pydev_original_step_cmd = CMD_SMART_STEP_INTO
  info.pydev_step_cmd = CMD_SMART_STEP_INTO
@@ -714,7 +714,7 @@ def __init__(self, thread_id, cmd_id, line, func_name, seq=0):
 
  def do_it(self, dbg):
  t = pydevd_find_thread_by_id(self.thread_id)
- if t:
+ if t is not None:
  info = t.additional_info
  info.pydev_original_step_cmd = self.cmd_id
  info.pydev_step_cmd = self.cmd_id
@@ -1401,11 +1401,10 @@ def internal_get_description(dbg, seq, thread_id, frame_id, expression):
  dbg.writer.add_command(cmd)
 
 
-def build_exception_info_response(dbg, thread_id, request_seq, set_additional_thread_info, iter_visible_frames_info, max_frames):
+def build_exception_info_response(dbg, thread_id, thread, request_seq, set_additional_thread_info, iter_visible_frames_info, max_frames):
  '''
  :return ExceptionInfoResponse
  '''
- thread = pydevd_find_thread_by_id(thread_id)
  additional_info = set_additional_thread_info(thread)
  topmost_frame = additional_info.get_topmost_frame(thread)
 
@@ -1540,11 +1539,11 @@ def build_exception_info_response(dbg, thread_id, request_seq, set_additional_th
  return response
 
 
-def internal_get_exception_details_json(dbg, request, thread_id, max_frames, set_additional_thread_info=None, iter_visible_frames_info=None):
+def internal_get_exception_details_json(dbg, request, thread_id, thread, max_frames, set_additional_thread_info=None, iter_visible_frames_info=None):
  ''' Fetch exception details
  '''
  try:
- response = build_exception_info_response(dbg, thread_id, request.seq, set_additional_thread_info, iter_visible_frames_info, max_frames)
+ response = build_exception_info_response(dbg, thread_id, thread, request.seq, set_additional_thread_info, iter_visible_frames_info, max_frames)
  except:
  exc = get_exception_traceback_str()
  response = pydevd_base_schema.build_response(request, kwargs={

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

@@ -28,7 +28,6 @@
 from _pydevd_bundle.pydevd_additional_thread_info import set_additional_thread_info
 from _pydevd_bundle import pydevd_frame_utils, pydevd_constants, pydevd_utils
 import linecache
-from _pydevd_bundle.pydevd_thread_lifecycle import pydevd_find_thread_by_id
 from io import StringIO
 from _pydev_bundle import pydev_log
 
@@ -346,10 +345,9 @@ def make_console_message(self, msg):
  ])
 
  @overrides(NetCommandFactory.make_thread_suspend_single_notification)
- def make_thread_suspend_single_notification(self, py_db, thread_id, stop_reason):
+ def make_thread_suspend_single_notification(self, py_db, thread_id, thread, stop_reason):
  exc_desc = None
  exc_name = None
- thread = pydevd_find_thread_by_id(thread_id)
  info = set_additional_thread_info(thread)
 
  preserve_focus_hint = False
@@ -375,7 +373,7 @@ def make_thread_suspend_single_notification(self, py_db, thread_id, stop_reason)
 
  if stop_reason == 'exception':
  exception_info_response = build_exception_info_response(
- py_db, thread_id, -1, set_additional_thread_info, self._iter_visible_frames_info, max_frames=-1)
+ py_db, thread_id, thread, -1, set_additional_thread_info, self._iter_visible_frames_info, max_frames=-1)
  exception_info_response
 
  exc_name = exception_info_response.body.exceptionId

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

@@ -293,7 +293,7 @@ def make_thread_suspend_message(self, py_db, thread_id, frames_list, stop_reason
  except:
  return self.make_error_message(0, get_exception_traceback_str())
 
- def make_thread_suspend_single_notification(self, py_db, thread_id, stop_reason):
+ def make_thread_suspend_single_notification(self, py_db, thread_id, thread, stop_reason):
  try:
  return NetCommand(CMD_THREAD_SUSPEND_SINGLE_NOTIFICATION, 0, json.dumps(
  {'thread_id': thread_id, 'stop_reason':stop_reason}))

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

@@ -743,10 +743,11 @@ def cmd_get_exception_details(self, py_db, cmd_id, seq, text):
  thread_id = text
  t = pydevd_find_thread_by_id(thread_id)
  frame = None
- if t and not getattr(t, 'pydev_do_not_trace', None):
+ if t is not None and not getattr(t, 'pydev_do_not_trace', None):
  additional_info = set_additional_thread_info(t)
  frame = additional_info.get_topmost_frame(t)
  try:
+ # Note: provide the return even if the thread is empty.
  return py_db.cmd_factory.make_get_exception_details_message(py_db, seq, thread_id, frame)
  finally:
  frame = None

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

@@ -575,6 +575,16 @@ def on_stepin_request(self, py_db, request):
  target_id = arguments.targetId
  if target_id is not None:
  thread = pydevd_find_thread_by_id(thread_id)
+ if thread is None:
+ response = Response(
+ request_seq=request.seq,
+ success=False,
+ command=request.command,
+ message='Unable to find thread from thread_id: %s' % (thread_id,),
+ body={},
+ )
+ return NetCommand(CMD_RETURN, 0, response, is_json=True)
+
  info = set_additional_thread_info(thread)
  target_id_to_smart_step_into_variant = info.target_id_to_smart_step_into_variant
  if not target_id_to_smart_step_into_variant:
@@ -978,7 +988,18 @@ def on_exceptioninfo_request(self, py_db, request):
  exception_into_arguments = request.arguments
  thread_id = exception_into_arguments.threadId
  max_frames = self._options.max_exception_stack_frames
- self.api.request_exception_info_json(py_db, request, thread_id, max_frames)
+ thread = pydevd_find_thread_by_id(thread_id)
+ if thread is not None:
+ self.api.request_exception_info_json(py_db, request, thread_id, thread, max_frames)
+ else:
+ response = Response(
+ request_seq=request.seq,
+ success=False,
+ command=request.command,
+ message='Unable to find thread from thread_id: %s' % (thread_id,),
+ body={},
+ )
+ return NetCommand(CMD_RETURN, 0, response, is_json=True)
 
  def on_scopes_request(self, py_db, request):
  '''

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

@@ -325,7 +325,7 @@ def on_timeout_unblock_threads():
  on_timeout_unblock_threads.called = True
  pydev_log.info('Resuming threads after evaluate timeout.')
  resume_threads('*', except_thread=curr_thread)
- py_db.threads_suspended_single_notification.on_thread_resume(tid)
+ py_db.threads_suspended_single_notification.on_thread_resume(tid, curr_thread)
 
  on_timeout_unblock_threads.called = False
 
@@ -341,7 +341,7 @@ def on_timeout_unblock_threads():
  mark_thread_suspended(curr_thread, CMD_SET_BREAK)
  py_db.threads_suspended_single_notification.increment_suspend_time()
  suspend_all_threads(py_db, except_thread=curr_thread)
- py_db.threads_suspended_single_notification.on_thread_suspend(tid, CMD_SET_BREAK)
+ py_db.threads_suspended_single_notification.on_thread_suspend(tid, curr_thread, CMD_SET_BREAK)
 
 
 def _evaluate_with_timeouts(original_func):

src/debugpy/_vendored/pydevd/pydevd.py

@@ -298,7 +298,7 @@ class AbstractSingleNotificationBehavior(object):
 
  # On do_wait_suspend, use notify_thread_suspended:
  def do_wait_suspend(...):
- with single_notification_behavior.notify_thread_suspended(thread_id):
+ with single_notification_behavior.notify_thread_suspended(thread_id, thread, reason):
  ...
  '''
 
@@ -308,7 +308,7 @@ def do_wait_suspend(...):
  '_lock',
  '_next_request_time',
  '_suspend_time_request',
- '_suspended_thread_ids',
+ '_suspended_thread_id_to_thread',
  '_pause_requested',
  '_py_db',
  ]
@@ -322,10 +322,10 @@ def __init__(self, py_db):
  self._last_resume_notification_time = -1
  self._suspend_time_request = self._next_request_time()
  self._lock = thread.allocate_lock()
- self._suspended_thread_ids = set()
+ self._suspended_thread_id_to_thread = {}
  self._pause_requested = False
 
- def send_suspend_notification(self, thread_id, stop_reason):
+ def send_suspend_notification(self, thread_id, thread, stop_reason):
  raise AssertionError('abstract: subclasses must override.')
 
  def send_resume_notification(self, thread_id):
@@ -351,29 +351,30 @@ def on_pause(self):
 
  def _notify_after_timeout(self, global_suspend_time):
  with self._lock:
- if self._suspended_thread_ids:
+ if self._suspended_thread_id_to_thread:
  if global_suspend_time > self._last_suspend_notification_time:
  self._last_suspend_notification_time = global_suspend_time
  # Notify about any thread which is currently suspended.
  pydev_log.info('Sending suspend notification after timeout.')
- self.send_suspend_notification(next(iter(self._suspended_thread_ids)), CMD_THREAD_SUSPEND)
+ thread_id, thread = next(iter(self._suspended_thread_id_to_thread.items()))
+ self.send_suspend_notification(thread_id, thread, CMD_THREAD_SUSPEND)
 
- def on_thread_suspend(self, thread_id, stop_reason):
+ def on_thread_suspend(self, thread_id, thread, stop_reason):
  with self._lock:
  pause_requested = self._pause_requested
  if pause_requested:
  # When a suspend notification is sent, reset the pause flag.
  self._pause_requested = False
 
- self._suspended_thread_ids.add(thread_id)
+ self._suspended_thread_id_to_thread[thread_id] = thread
 
  # CMD_THREAD_SUSPEND should always be a side-effect of a break, so, only
  # issue for a CMD_THREAD_SUSPEND if a pause is pending.
  if stop_reason != CMD_THREAD_SUSPEND or pause_requested:
  if self._suspend_time_request > self._last_suspend_notification_time:
  pydev_log.info('Sending suspend notification.')
  self._last_suspend_notification_time = self._suspend_time_request
- self.send_suspend_notification(thread_id, stop_reason)
+ self.send_suspend_notification(thread_id, thread, stop_reason)
  else:
  pydev_log.info(
  'Suspend not sent (it was already sent). Last suspend % <= Last resume %s',
@@ -385,10 +386,10 @@ def on_thread_suspend(self, thread_id, stop_reason):
  'Suspend not sent because stop reason is thread suspend and pause was not requested.',
  )
 
- def on_thread_resume(self, thread_id):
+ def on_thread_resume(self, thread_id, thread):
  # on resume (step, continue all):
  with self._lock:
- self._suspended_thread_ids.remove(thread_id)
+ self._suspended_thread_id_to_thread.pop(thread_id)
  if self._last_resume_notification_time < self._last_suspend_notification_time:
  pydev_log.info('Sending resume notification.')
  self._last_resume_notification_time = self._last_suspend_notification_time
@@ -401,12 +402,12 @@ def on_thread_resume(self, thread_id):
  )
 
  @contextmanager
- def notify_thread_suspended(self, thread_id, stop_reason):
- self.on_thread_suspend(thread_id, stop_reason)
+ def notify_thread_suspended(self, thread_id, thread, stop_reason):
+ self.on_thread_suspend(thread_id, thread, stop_reason)
  try:
  yield # At this point the thread must be actually suspended.
  finally:
- self.on_thread_resume(thread_id)
+ self.on_thread_resume(thread_id, thread)
 
 
 class ThreadsSuspendedSingleNotification(AbstractSingleNotificationBehavior):
@@ -439,16 +440,18 @@ def send_resume_notification(self, thread_id):
  callback()
 
  @overrides(AbstractSingleNotificationBehavior.send_suspend_notification)
- def send_suspend_notification(self, thread_id, stop_reason):
+ def send_suspend_notification(self, thread_id, thread, stop_reason):
  py_db = self._py_db()
  if py_db is not None:
- py_db.writer.add_command(py_db.cmd_factory.make_thread_suspend_single_notification(py_db, thread_id, stop_reason))
+ py_db.writer.add_command(
+ py_db.cmd_factory.make_thread_suspend_single_notification(
+ py_db, thread_id, thread, stop_reason))
 
  @overrides(AbstractSingleNotificationBehavior.notify_thread_suspended)
  @contextmanager
- def notify_thread_suspended(self, thread_id, stop_reason):
+ def notify_thread_suspended(self, thread_id, thread, stop_reason):
  if self.multi_threads_single_notification:
- with AbstractSingleNotificationBehavior.notify_thread_suspended(self, thread_id, stop_reason):
+ with AbstractSingleNotificationBehavior.notify_thread_suspended(self, thread_id, thread, stop_reason):
  yield
  else:
  yield
@@ -2063,7 +2066,7 @@ def do_wait_suspend(self, thread, frame, event, arg, exception_type=None): # @U
 
  from_this_thread.append(frame_custom_thread_id)
 
- with self._threads_suspended_single_notification.notify_thread_suspended(thread_id, stop_reason):
+ with self._threads_suspended_single_notification.notify_thread_suspended(thread_id, thread, stop_reason):
  keep_suspended = self._do_wait_suspend(thread, frame, event, arg, suspend_type, from_this_thread, frames_tracker)
 
  frames_list = None

src/debugpy/_vendored/pydevd/tests_python/tests_single_notification.py → src/debugpy/_vendored/pydevd/tests_python/test_single_notification.py

@@ -8,6 +8,7 @@
 from _pydevd_bundle.pydevd_daemon_thread import run_as_pydevd_daemon_thread
 from tests_python.debugger_unittest import CMD_THREAD_SUSPEND, CMD_STEP_OVER, CMD_SET_BREAK
 from _pydev_bundle.pydev_override import overrides
+import threading
 
 STATE_RUN = 1
 STATE_SUSPEND = 2
@@ -19,6 +20,7 @@ class _ThreadInfo(object):
 
  def __init__(self):
  self.state = STATE_RUN
+ self.thread = threading.Thread()
  self.thread_id = self.next_thread_id()
 
 
@@ -47,7 +49,7 @@ def send_suspend_notification(self, *args, **kwargs):
  self.notification_queue.put('suspend')
 
  def do_wait_suspend(self, thread_info, stop_reason):
- with self.notify_thread_suspended(thread_info.thread_id, stop_reason=stop_reason):
+ with self.notify_thread_suspended(thread_info.thread_id, thread_info.thread, stop_reason=stop_reason):
  while thread_info.state == STATE_SUSPEND:
  time.sleep(.1)
 
@@ -93,7 +95,9 @@ def join_thread(t):
 class _DummyPyDB(object):
 
  def __init__(self):
+ from _pydevd_bundle.pydevd_timeout import TimeoutTracker
  self.created_pydb_daemon_threads = {}
+ self.timeout_tracker = TimeoutTracker(self)
 
 
 def test_single_notification_1(single_notification_behavior, notification_queue):
@@ -230,7 +234,7 @@ def test_single_notification_3(single_notification_behavior, notification_queue,
 
  join_thread(t2)
  assert notification_queue.qsize() == 0
- assert not single_notification_behavior._suspended_thread_ids
+ assert not single_notification_behavior._suspended_thread_id_to_thread
 
  # Now, no threads are running and pause is pressed
  # (maybe we could do a thread dump in this case as this