eric: comparison eric6/DebugClients/Python/ThreadExtension.py

-:866adc8c315b
+:0acf98cd089a
 """
 Module implementing an import hook patching thread modules to get debugged too.
 """
-import os.path
+import os
 import sys
-import importlib
 import _thread
 import threading
 from DebugBase import DebugBase
 class ThreadExtension(object):
 """
 Class implementing the thread support for the debugger.
-Provides methods for intercepting thread creation, retriving the running
+Provides methods for intercepting thread creation, retrieving the running
 threads and their name and state.
 """
 def __init__(self):
 """
 Constructor
 """
 self.threadNumber = 1
-self.enableImportHooks = True
 self._original_start_new_thread = None
-self.threadingAttached = False
-self.qtThreadAttached = False
-self.greenlet = False
 self.clientLock = threading.RLock()
 # dictionary of all threads running {id: DebugBase}
 self.threads = {_thread.get_ident(): self}
 # the thread we are at a breakpoint continuing at next command
 self.currentThreadExec = self
 # special objects representing the main scripts thread and frame
 self.mainThread = self
-# reset already imported thread module to apply hooks at next import
-del sys.modules['_thread']
-del sys.modules['threading']
-sys.meta_path.insert(0, self)
 def attachThread(self, target=None, args=None, kwargs=None,
 mainThread=False):
 """
 Public method to setup a standard thread for DebugClient to debug.
 @param blocking flag to indicating a blocking lock
 @type bool
 @return flag indicating successful locking
 @rtype bool
 """
-if blocking:
+return self.clientLock.acquire(blocking)
-return self.clientLock.acquire()
-else:
-return self.clientLock.acquire(blocking)
 def unlockClient(self):
 """
 Public method to release the lock for this client.
 """
 try:
 self.clientLock.release()
-except AssertionError:
+except RuntimeError:
 pass
 def setCurrentThread(self, threadId):
 """
 Public method to set the current thread.
 def dumpThreadList(self):
 """
 Public method to send the list of threads.
 """
 self.updateThreadList()
 threadList = []
-if len(self.threads) > 1:
+currentId = _thread.get_ident()
-currentId = _thread.get_ident()
+# update thread names set by user (threading.setName)
-# update thread names set by user (threading.setName)
+threadNames = {t.ident: t.getName() for t in threading.enumerate()}
-threadNames = {t.ident: t.getName() for t in threading.enumerate()}
+for threadId, thd in self.threads.items():
-for threadId, thd in self.threads.items():
+d = {"id": threadId}
-d = {"id": threadId}
+try:
-try:
+d["name"] = threadNames.get(threadId, thd.name)
-d["name"] = threadNames.get(threadId, thd.name)
+d["broken"] = thd.isBroken
-d["broken"] = thd.isBroken
+d["except"] = thd.isException
 except Exception:
 d["name"] = 'UnknownThread'
 d["broken"] = False
+d["except"] = False
-threadList.append(d)
-else:
-currentId = -1
-d = {"id": -1}
-d["name"] = "MainThread"
-d["broken"] = self.isBroken
 threadList.append(d)
 self.sendJsonCommand("ResponseThreadList", {
 "currentID": currentId,
 "threadList": threadList,
 # Clean up obsolet because terminated threads
 self.threads = {id_: thrd for id_, thrd in self.threads.items()
 if id_ in frames}
-def find_module(self, fullname, path=None):
+#######################################################################
-"""
+## Methods below deal with patching various modules to support
-Public method returning the module loader.
+## debugging of threads.
+#######################################################################
-@param fullname name of the module to be loaded
-@type str
+def patchPyThread(self, module):
-@param path path to resolve the module name
+"""
-@type str
+Public method to patch Python _thread (Python3) and thread (Python2)
-@return module loader object
+modules.
-@rtype object
-"""
+@param module reference to the imported module to be patched
-if fullname in sys.modules or not self.debugging:
+@type module
-return None
+"""
+# make thread hooks available to system
-if fullname in ['_thread', 'PyQt5.QtCore', 'PySide2.QtCore',
+self._original_start_new_thread = module.start_new_thread
-'greenlet', 'threading'
+module.start_new_thread = self.attachThread
-] and self.enableImportHooks:
-# Disable hook to be able to import original module
+def patchGreenlet(self, module):
-self.enableImportHooks = False
+"""
-return self
+Public method to patch the 'greenlet' module.
-return None
+@param module reference to the imported module to be patched
+@type module
-def load_module(self, fullname):
+@return flag indicating that the module was processed
-"""
+@rtype bool
-Public method to load a module.
+"""
+# Check for greenlet.settrace
-@param fullname name of the module to be loaded
+if hasattr(module, 'settrace'):
-@type str
+DebugBase.pollTimerEnabled = False
-@return reference to the loaded module
+return True
-@rtype module
+return False
-"""
-module = importlib.import_module(fullname)
+def patchPyThreading(self, module):
-sys.modules[fullname] = module
+"""
-if (fullname == '_thread' and
+Public method to patch the Python threading module.
-self._original_start_new_thread is None):
-# make thread hooks available to system
+@param module reference to the imported module to be patched
-self._original_start_new_thread = module.start_new_thread
+@type module
-module.start_new_thread = self.attachThread
+"""
+# _debugClient as a class attribute can't be accessed in following
-elif (fullname == 'greenlet' and self.greenlet is False):
+# class. Therefore we need a global variable.
-# Check for greenlet.settrace
+_debugClient = self
-if hasattr(module, 'settrace'):
-self.greenlet = True
+def _bootstrap(self, run):
-DebugBase.pollTimerEnabled = False
+"""
+Bootstrap for threading, which reports exceptions correctly.
-# Add hook for threading.run()
-elif (fullname == "threading" and self.threadingAttached is False):
+@param run the run method of threading.Thread
-self.threadingAttached = True
+@type method pointer
+"""
-# _debugClient as a class attribute can't be accessed in following
+newThread = DebugBase(_debugClient)
-# class. Therefore we need a global variable.
+newThread.name = self.name
-_debugClient = self
+_debugClient.threads[self.ident] = newThread
-def _bootstrap(self, run):
+_debugClient.dumpThreadList()
-"""
-Bootstrap for threading, which reports exceptions correctly.
+# see DebugBase.bootstrap
+sys.settrace(newThread.trace_dispatch)
+try:
+run()
+except Exception:
+excinfo = sys.exc_info()
+newThread.user_exception(excinfo, True)
+finally:
+sys.settrace(None)
+_debugClient.dumpThreadList()
+class ThreadWrapper(module.Thread):
+"""
+Wrapper class for threading.Thread.
+"""
+def __init__(self, *args, **kwargs):
+"""
+Constructor
+"""
+# Overwrite the provided run method with our own, to
+# intercept the thread creation by threading.Thread
+self.run = lambda s=self, run=self.run: _bootstrap(s, run)
-@param run the run method of threading.Thread
+super(ThreadWrapper, self).__init__(*args, **kwargs)
-@type method pointer
-"""
+module.Thread = ThreadWrapper
-newThread = DebugBase(_debugClient)
-_debugClient.threads[self.ident] = newThread
+# Special handling of threading.(_)Timer
-newThread.name = self.name
+timer = module.Timer
-# see DebugBase.bootstrap
-sys.settrace(newThread.trace_dispatch)
+class TimerWrapper(timer, ThreadWrapper):
-try:
+"""
-run()
+Wrapper class for threading.(_)Timer.
-except Exception:
+"""
-excinfo = sys.exc_info()
+def __init__(self, interval, function, *args, **kwargs):
-newThread.user_exception(excinfo, True)
+"""
-finally:
+Constructor
-sys.settrace(None)
+"""
+super(TimerWrapper, self).__init__(
-class ThreadWrapper(module.Thread):
+interval, function, *args, **kwargs)
-"""
-Wrapper class for threading.Thread.
+module.Timer = TimerWrapper
-"""
-def __init__(self, *args, **kwargs):
+# Special handling of threading._DummyThread
-"""
+class DummyThreadWrapper(module._DummyThread, ThreadWrapper):
-Constructor
+"""
-"""
+Wrapper class for threading._DummyThread.
-# Overwrite the provided run method with our own, to
+"""
-# intercept the thread creation by threading.Thread
+def __init__(self, *args, **kwargs):
-self.run = lambda s=self, run=self.run: _bootstrap(s, run)
+"""
+Constructor
-super(ThreadWrapper, self).__init__(*args, **kwargs)
+"""
+super(DummyThreadWrapper, self).__init__(*args, **kwargs)
-module.Thread = ThreadWrapper
+module._DummyThread = DummyThreadWrapper
-# Special handling of threading.(_)Timer
-timer = module.Timer
+def patchQThread(self, module):
+"""
+Public method to patch the QtCore module's QThread.
+@param module reference to the imported module to be patched
+@type module
+"""
+# _debugClient as a class attribute can't be accessed in following
+# class. Therefore we need a global variable.
+_debugClient = self
+def _bootstrapQThread(self, run):
+"""
+Bootstrap for QThread, which reports exceptions correctly.
+@param run the run method of *.QThread
+@type method pointer
+"""
+global _qtThreadNumber
+newThread = DebugBase(_debugClient)
+ident = _thread.get_ident()
+name = 'QtThread-{0}'.format(_qtThreadNumber)
+_qtThreadNumber += 1
+newThread.id = ident
+newThread.name = name
+_debugClient.threads[ident] = newThread
+_debugClient.dumpThreadList()
+# see DebugBase.bootstrap
+sys.settrace(newThread.trace_dispatch)
+try:
+run()
+except SystemExit:
+# *.QThreads doesn't like SystemExit
+pass
+except Exception:
+excinfo = sys.exc_info()
+newThread.user_exception(excinfo, True)
+finally:
+sys.settrace(None)
+_debugClient.dumpThreadList()
+class QThreadWrapper(module.QThread):
+"""
+Wrapper class for *.QThread.
+"""
+def __init__(self, *args, **kwargs):
+"""
+Constructor
+"""
+# Overwrite the provided run method with our own, to
+# intercept the thread creation by Qt
+self.run = lambda s=self, run=self.run: (
+_bootstrapQThread(s, run))
-class TimerWrapper(timer, ThreadWrapper):
+super(QThreadWrapper, self).__init__(*args, **kwargs)
-"""
-Wrapper class for threading.(_)Timer.
+class QRunnableWrapper(module.QRunnable):
 """
-def __init__(self, interval, function, *args, **kwargs):
+Wrapper class for *.QRunnable.
 """
-Constructor
+def __init__(self, *args, **kwargs):
 """
-super(TimerWrapper, self).__init__(
+Constructor
-interval, function, *args, **kwargs)
+"""
+# Overwrite the provided run method with our own, to
-module.Timer = TimerWrapper
+# intercept the thread creation by Qt
+self.run = lambda s=self, run=self.run: (
-# Special handling of threading._DummyThread
+_bootstrapQThread(s, run))
-class DummyThreadWrapper(module._DummyThread, ThreadWrapper):
-"""
-Wrapper class for threading._DummyThread.
-"""
-def __init__(self, *args, **kwargs):
-"""
-Constructor
-"""
-super(DummyThreadWrapper, self).__init__(*args, **kwargs)
-module._DummyThread = DummyThreadWrapper
-# Add hook for *.QThread
-elif (fullname in ['PyQt5.QtCore', 'PySide2.QtCore'] and
-self.qtThreadAttached is False):
-self.qtThreadAttached = True
-# _debugClient as a class attribute can't be accessed in following
-# class. Therefore we need a global variable.
-_debugClient = self
-def _bootstrapQThread(self, run):
-"""
-Bootstrap for QThread, which reports exceptions correctly.
-@param run the run method of *.QThread
+super(QRunnableWrapper, self).__init__(*args, **kwargs)
-@type method pointer
-"""
+module.QThread = QThreadWrapper
-global _qtThreadNumber
+module.QRunnable = QRunnableWrapper
-newThread = DebugBase(_debugClient)
-ident = _thread.get_ident()
-name = 'QtThread-{0}'.format(_qtThreadNumber)
-_qtThreadNumber += 1
-newThread.id = ident
-newThread.name = name
-_debugClient.threads[ident] = newThread
-# see DebugBase.bootstrap
-sys.settrace(newThread.trace_dispatch)
-try:
-run()
-except SystemExit:
-# *.QThreads doesn't like SystemExit
-pass
-except Exception:
-excinfo = sys.exc_info()
-newThread.user_exception(excinfo, True)
-finally:
-sys.settrace(None)
-class QThreadWrapper(module.QThread):
-"""
-Wrapper class for *.QThread.
-"""
-def __init__(self, *args, **kwargs):
-"""
-Constructor
-"""
-# Overwrite the provided run method with our own, to
-# intercept the thread creation by Qt
-self.run = lambda s=self, run=self.run: (
-_bootstrapQThread(s, run))
-super(QThreadWrapper, self).__init__(*args, **kwargs)
-class QRunnableWrapper(module.QRunnable):
-"""
-Wrapper class for *.QRunnable.
-"""
-def __init__(self, *args, **kwargs):
-"""
-Constructor
-"""
-# Overwrite the provided run method with our own, to
-# intercept the thread creation by Qt
-self.run = lambda s=self, run=self.run: (
-_bootstrapQThread(s, run))
-super(QRunnableWrapper, self).__init__(*args, **kwargs)
-module.QThread = QThreadWrapper
-module.QRunnable = QRunnableWrapper
-self.enableImportHooks = True
-return module

Mercurial Repositories > eric / file comparison

comparison: eric6/DebugClients/Python/ThreadExtension.py

eric6/DebugClients/Python/ThreadExtension.py