#---------------------------------------------------------------------------- # Name: DebuggerHarness.py # Purpose: # # Author: Matt Fryer # # Created: 7/28/04 # CVS-ID: $Id$ # Copyright: (c) 2005 ActiveGrid, Inc. # License: wxWindows License #---------------------------------------------------------------------------- import bdb import sys import SimpleXMLRPCServer import threading import xmlrpclib import os import types import Queue import traceback import inspect from xml.dom.minidom import getDOMImplementation import atexit import pickle import cStringIO import bz2 if sys.platform.startswith("win"): import win32api _WINDOWS = True else: _WINDOWS = False _VERBOSE = False _DEBUG_DEBUGGER = False class Adb(bdb.Bdb): def __init__(self, harness, queue): bdb.Bdb.__init__(self) self._harness = harness self._userBreak = False self._queue = queue self._knownCantExpandFiles = {} self._knownExpandedFiles = {} def getLongName(self, filename): if not _WINDOWS: return filename if self._knownCantExpandFiles.get(filename): return filename if self._knownExpandedFiles.get(filename): return self._knownExpandedFiles.get(filename) try: newname = win32api.GetLongPathName(filename) self._knownExpandedFiles[filename] = newname return newname except: self._knownCantExpandFiles[filename] = filename return filename def canonic(self, orig_filename): if orig_filename == "<" + orig_filename[1:-1] + ">": return orig_filename filename = self.getLongName(orig_filename) canonic = self.fncache.get(filename) if not canonic: canonic = os.path.abspath(filename) canonic = os.path.normcase(canonic) self.fncache[filename] = canonic return canonic # Overriding this so that we continue to trace even if no breakpoints are set. def set_continue(self): self.stopframe = self.botframe self.returnframe = None self.quitting = 0 def do_clear(self, arg): bdb.Breakpoint.bpbynumber[int(arg)].deleteMe() def user_line(self, frame): if self.in_debugger_code(frame): self.set_step() return message = self.__frame2message(frame) self._harness.interaction(message, frame, "") def user_call(self, frame, argument_list): if self.in_debugger_code(frame): self.set_step() return if self.stop_here(frame): message = self.__frame2message(frame) self._harness.interaction(message, frame, "") def user_return(self, frame, return_value): if self.in_debugger_code(frame): self.set_step() return message = self.__frame2message(frame) self._harness.interaction(message, frame, "") def user_exception(self, frame, (exc_type, exc_value, exc_traceback)): frame.f_locals['__exception__'] = exc_type, exc_value if type(exc_type) == type(''): exc_type_name = exc_type else: exc_type_name = exc_type.__name__ message = "Exception occured: " + repr(exc_type_name) + " See locals.__exception__ for details." traceback.print_exception(exc_type, exc_value, exc_traceback) self._harness.interaction(message, frame, message) def in_debugger_code(self, frame): if _DEBUG_DEBUGGER: return False message = self.__frame2message(frame) return message.count('DebuggerHarness') > 0 def frame2message(self, frame): return self.__frame2message(frame) def __frame2message(self, frame): code = frame.f_code filename = code.co_filename lineno = frame.f_lineno basename = os.path.basename(filename) message = "%s:%s" % (basename, lineno) if code.co_name != "?": message = "%s: %s()" % (message, code.co_name) return message def runFile(self, fileName): self.reset() #global_dict = {} #global_dict['__name__'] = '__main__' try: fileToRun = open(fileName, mode='r') if _VERBOSE: print "Running file ", fileName sys.settrace(self.trace_dispatch) import __main__ exec fileToRun in __main__.__dict__,__main__.__dict__ except SystemExit: pass except: tp, val, tb = sys.exc_info() traceback.print_exception(tp, val, tb) sys.settrace(None) self.quitting = 1 #global_dict.clear() def trace_dispatch(self, frame, event, arg): if self.quitting: return # None # Check for ui events self.readQueue() if event == 'line': return self.dispatch_line(frame) if event == 'call': return self.dispatch_call(frame, arg) if event == 'return': return self.dispatch_return(frame, arg) if event == 'exception': return self.dispatch_exception(frame, arg) print 'Adb.dispatch: unknown debugging event:', `event` return self.trace_dispatch def readQueue(self): while self._queue.qsize(): try: item = self._queue.get_nowait() if item.kill(): self._harness.do_exit(kill=True) elif item.breakHere(): self._userBreak = True elif item.hasBreakpoints(): self.set_all_breakpoints(item.getBreakpoints()) except Queue.Empty: pass def set_all_breakpoints(self, dict): self.clear_all_breaks() for fileName in dict.keys(): lineList = dict[fileName] for lineNumber in lineList: if _VERBOSE: print "Setting break at line ", str(lineNumber), " in file ", self.canonic(fileName) self.set_break(fileName, int(lineNumber)) return "" def stop_here(self, frame): if self._userBreak: return True # (CT) stopframe may now also be None, see dispatch_call. # (CT) the former test for None is therefore removed from here. if frame is self.stopframe: return True while frame is not None and frame is not self.stopframe: if frame is self.botframe: return True frame = frame.f_back return False class BreakNotify(object): def __init__(self, bps=None, break_here=False, kill=False): self._bps = bps self._break_here = break_here self._kill = kill def breakHere(self): return self._break_here def kill(self): return self._kill def getBreakpoints(self): return self._bps def hasBreakpoints(self): return (self._bps != None) class AGXMLRPCServer(SimpleXMLRPCServer.SimpleXMLRPCServer): def __init__(self, address, logRequests=0): SimpleXMLRPCServer.SimpleXMLRPCServer.__init__(self, address, logRequests=logRequests) class BreakListenerThread(threading.Thread): def __init__(self, host, port, queue): threading.Thread.__init__(self) self._host = host self._port = int(port) self._keepGoing = True self._queue = queue self._server = AGXMLRPCServer((self._host, self._port), logRequests=0) self._server.register_function(self.update_breakpoints) self._server.register_function(self.break_requested) self._server.register_function(self.die) def break_requested(self): bn = BreakNotify(break_here=True) self._queue.put(bn) return "" def update_breakpoints(self, pickled_Binary_bpts): dict = pickle.loads(pickled_Binary_bpts.data) bn = BreakNotify(bps=dict) self._queue.put(bn) return "" def die(self): bn = BreakNotify(kill=True) self._queue.put(bn) return "" def run(self): while self._keepGoing: try: self._server.handle_request() except: if _VERBOSE: tp, val, tb = sys.exc_info() print "Exception in BreakListenerThread.run():", str(tp), str(val) self._keepGoing = False def AskToStop(self): self._keepGoing = False if type(self._server) is not types.NoneType: if _VERBOSE: print "Before calling server close on breakpoint server" self._server.server_close() if _VERBOSE: print "Calling server close on breakpoint server" self._server = None class DebuggerHarness(object): def __init__(self): # Host and port for debugger-side RPC server self._hostname = sys.argv[1] self._portNumber = int(sys.argv[2]) # Name the gui proxy object is registered under self._breakPortNumber = int(sys.argv[3]) # Host and port where the gui proxy can be found. self._guiHost = sys.argv[4] self._guiPort = int(sys.argv[5]) # Command to debug. self._command = sys.argv[6] # Strip out the harness' arguments so that the process we run will see argv as if # it was called directly. sys.argv = sys.argv[6:] self._currentFrame = None self._wait = False # Connect to the gui-side RPC server. self._guiServerUrl = 'http://' + self._guiHost + ':' + str(self._guiPort) + '/' if _VERBOSE: print "Connecting to gui server at ", self._guiServerUrl self._guiServer = xmlrpclib.ServerProxy(self._guiServerUrl,allow_none=1) # Start the break listener self._breakQueue = Queue.Queue(50) self._breakListener = BreakListenerThread(self._hostname, self._breakPortNumber, self._breakQueue) self._breakListener.start() # Create the debugger. self._adb = Adb(self, self._breakQueue) # Create the debugger-side RPC Server and register functions for remote calls. self._server = AGXMLRPCServer((self._hostname, self._portNumber), logRequests=0) self._server.register_function(self.set_step) self._server.register_function(self.set_continue) self._server.register_function(self.set_next) self._server.register_function(self.set_return) self._server.register_function(self.set_breakpoint) self._server.register_function(self.clear_breakpoint) self._server.register_function(self.set_all_breakpoints) self._server.register_function(self.attempt_introspection) self._server.register_function(self.execute_in_frame) self._server.register_function(self.add_watch) self._server.register_function(self.request_frame_document) self.frame_stack = [] self.message_frame_dict = {} self.introspection_list = [] atexit.register(self.do_exit) def run(self): self._adb.runFile(self._command) self.do_exit(kill=True) def do_exit(self, kill=False): self._adb.set_quit() self._breakListener.AskToStop() self._server.server_close() try: self._guiServer.quit() except: pass if kill: try: sys.exit() except: pass def set_breakpoint(self, fileName, lineNo): self._adb.set_break(fileName, lineNo) return "" def set_all_breakpoints(self, dict): self._adb.clear_all_breaks() for fileName in dict.keys(): lineList = dict[fileName] for lineNumber in lineList: self._adb.set_break(fileName, int(lineNumber)) if _VERBOSE: print "Setting break at ", str(lineNumber), " in file ", fileName return "" def clear_breakpoint(self, fileName, lineNo): self._adb.clear_break(fileName, lineNo) return "" def add_watch(self, name, text, frame_message, run_once): if len(frame_message) > 0: frame = self.message_frame_dict[frame_message] try: item = eval(text, frame.f_globals, frame.f_locals) return self.get_watch_document(item, name) except: tp, val, tb = sys.exc_info() return self.get_exception_document(tp, val, tb) return "" def execute_in_frame(self, frame_message, command): frame = self.message_frame_dict[frame_message] output = cStringIO.StringIO() out = sys.stdout err = sys.stderr sys.stdout = output sys.stderr = output try: exec command in frame.f_globals, frame.f_locals return output.getvalue() sys.stdout = out sys.stderr = err except: sys.stdout = out sys.stderr = err tp, val, tb = sys.exc_info() output = cStringIO.StringIO() traceback.print_exception(tp, val, tb, file=output) return output.getvalue() def attempt_introspection(self, frame_message, chain): try: frame = self.message_frame_dict[frame_message] if frame: name = chain.pop(0) if name == 'globals': item = frame.f_globals elif name == 'locals': item = frame.f_locals for name in chain: item = self.getNextItem(item, name) return self.get_introspection_document(item, name) except: tp, val, tb = sys.exc_info() traceback.print_exception(tp, val, tb) return self.get_empty_introspection_document() def getNextItem(self, link, identifier): tp = type(link) if self.isTupleized(identifier): return self.deTupleize(link, identifier) else: if tp == types.DictType or tp == types.DictProxyType: return link[identifier] else: if hasattr(link, identifier): return getattr(link, identifier) if _VERBOSE or True: print "Failed to find link ", identifier, " on thing: ", self.saferepr(link), " of type ", repr(type(link)) return None def isPrimitive(self, item): tp = type(item) return tp is types.IntType or tp is types.LongType or tp is types.FloatType \ or tp is types.BooleanType or tp is types.ComplexType \ or tp is types.StringType def isTupleized(self, value): return value.count('[') def deTupleize(self, link, string1): try: start = string1.find('[') end = string1.find(']') num = int(string1[start+1:end]) return link[num] except: tp,val,tb = sys.exc_info() if _VERBOSE: print "Got exception in deTupleize: ", val return None def wrapAndCompress(self, stringDoc): import bz2 return xmlrpclib.Binary(bz2.compress(stringDoc)) def get_empty_introspection_document(self): doc = getDOMImplementation().createDocument(None, "replacement", None) return self.wrapAndCompress(doc.toxml()) def get_watch_document(self, item, identifier): doc = getDOMImplementation().createDocument(None, "watch", None) top_element = doc.documentElement self.addAny(top_element, identifier, item, doc, 2) return self.wrapAndCompress(doc.toxml()) def get_introspection_document(self, item, identifier): doc = getDOMImplementation().createDocument(None, "replacement", None) top_element = doc.documentElement self.addAny(top_element, identifier, item, doc, 2) return self.wrapAndCompress(doc.toxml()) def get_exception_document(self, name, tp, val, tb): stack = traceback.format_exception(tp, val, tb) wholeStack = "" for line in stack: wholeStack += line doc = getDOMImplementation().createDocument(None, "watch", None) top_element = doc.documentElement item_node = doc.createElement("dict_nv_element") item_node.setAttribute('value', wholeStack) item_node.setAttribute('name', str(name)) top_element.appendChild(item_node) cantIntro = [types.FunctionType, types.LambdaType, types.UnicodeType, types.StringType, types.NoneType, types.IntType, types.LongType, types.FloatType, types.BooleanType] def addAny(self, top_element, name, item, doc, ply): tp = type(item) if tp in DebuggerHarness.cantIntro or ply < 1: self.addNode(top_element,name, item, doc) elif tp is types.TupleType or tp is types.ListType: self.addTupleOrList(top_element, name, item, doc, ply - 1) elif tp is types.DictType or tp is types.DictProxyType: self.addDict(top_element, name, item, doc, ply -1) elif inspect.ismodule(item): self.addModule(top_element, name, item, doc, ply -1) elif inspect.isclass(item) or tp is types.InstanceType: self.addClass(top_element, name, item, doc, ply -1) elif hasattr(item, '__dict__'): self.addDictAttr(top_element, name, item, doc, ply -1) else: self.addNode(top_element,name, item, doc) def canIntrospect(self, item): tp = type(item) if tp in DebuggerHarness.cantIntro: return False elif tp is types.TupleType or tp is types.ListType: return len(item) > 0 elif tp is types.DictType or tp is types.DictProxyType: return len(item) > 0 elif inspect.ismodule(item): return True elif inspect.isclass(item) or tp is types.InstanceType: if hasattr(item, '__dict__'): return True elif hasattr(item, '__name__'): return True elif hasattr(item, '__module__'): return True elif hasattr(item, '__doc__'): return True else: return False elif hasattr(item, '__dict__'): return len(item.__dict__) > 0 else: return False def addNode(self, parent_node, name, item, document): item_node = document.createElement("dict_nv_element") item_node.setAttribute('value', self.saferepr(item)) item_node.setAttribute('name', str(name)) introVal = str(self.canIntrospect(item)) item_node.setAttribute('intro', str(introVal)) parent_node.appendChild(item_node) def addTupleOrList(self, top_node, name, tupple, doc, ply): tupleNode = doc.createElement('tuple') tupleNode.setAttribute('name', str(name)) tupleNode.setAttribute('value', self.saferepr(tupple)) top_node.appendChild(tupleNode) count = 0 for item in tupple: self.addAny(tupleNode, name +'[' + str(count) + ']',item, doc, ply -1) count += 1 def addDictAttr(self, root_node, name, thing, document, ply): dict_node = document.createElement('thing') dict_node.setAttribute('name', name) dict_node.setAttribute('value', self.saferepr(thing)) root_node.appendChild(dict_node) self.addDict(dict_node, '', thing.__dict__, document, ply) # Not decreminting ply def addDict(self, root_node, name, dict, document, ply): if name != '': dict_node = document.createElement('dict') dict_node.setAttribute('name', name) dict_node.setAttribute('value', self.saferepr(dict)) root_node.appendChild(dict_node) else: dict_node = root_node for key in dict.keys(): strkey = str(key) try: value = dict[key] self.addAny(dict_node, strkey, value, document, ply-1) except: if _VERBOSE: tp,val,tb=sys.exc_info() print "Error recovering key: ", str(key), " from node ", str(name), " Val = ", str(val) traceback.print_exception(tp, val, tb) def addClass(self, root_node, name, class_item, document, ply): item_node = document.createElement('class') item_node.setAttribute('name', str(name)) item_node.setAttribute('value', self.saferepr(class_item)) root_node.appendChild(item_node) try: if hasattr(class_item, '__dict__'): self.addDict(item_node, '', class_item.__dict__, document, ply -1) except: tp,val,tb=sys.exc_info() if _VERBOSE: traceback.print_exception(tp, val, tb) try: if hasattr(class_item, '__name__'): self.addAny(item_node,'__name__',class_item.__name__, document, ply -1) except: tp,val,tb=sys.exc_info() if _VERBOSE: traceback.print_exception(tp, val, tb) try: if hasattr(class_item, '__module__'): self.addAny(item_node, '__module__', class_item.__module__, document, ply -1) except: tp,val,tb=sys.exc_info() if _VERBOSE: traceback.print_exception(tp, val, tb) try: if hasattr(class_item, '__doc__'): self.addAny(item_node, '__doc__', class_item.__doc__, document, ply -1) except: tp,val,tb=sys.exc_info() if _VERBOSE: traceback.print_exception(tp, val, tb) try: if hasattr(class_item, '__bases__'): self.addAny(item_node, '__bases__', class_item.__bases__, document, ply -1) except: tp,val,tb=sys.exc_info() if _VERBOSE: traceback.print_exception(tp, val, tb) def addModule(self, root_node, name, module_item, document, ply): item_node = document.createElement('module') item_node.setAttribute('name', str(name)) item_node.setAttribute('value', self.saferepr(module_item)) root_node.appendChild(item_node) try: if hasattr(module_item, '__file__'): self.addAny(item_node, '__file__', module_item.__file__, document, ply -1) except: pass try: if hasattr(module_item, '__doc__'): self.addAny(item_node,'__doc__', module_item.__doc__, document, ply -1) except: pass def getFrameXML(self, base_frame): self.frame_stack = [] frame = base_frame while frame is not None: if((frame.f_code.co_filename.count('DebuggerHarness.py') == 0) or _DEBUG_DEBUGGER): self.frame_stack.append(frame) frame = frame.f_back self.frame_stack.reverse() self.message_frame_dict = {} doc = getDOMImplementation().createDocument(None, "stack", None) top_element = doc.documentElement numberFrames = len(self.frame_stack) for index in range(numberFrames): frame = self.frame_stack[index] message = self._adb.frame2message(frame) # We include globals and locals only for the last frame as an optimization for cases # where there are a lot of frames. self.addFrame(frame, top_element, doc, includeContent=(index == numberFrames - 1)) return doc.toxml() def addFrame(self, frame, root_element, document, includeContent=False): frameNode = document.createElement('frame') root_element.appendChild(frameNode) code = frame.f_code filename = code.co_filename frameNode.setAttribute('file', str(filename)) frameNode.setAttribute('line', str(frame.f_lineno)) message = self._adb.frame2message(frame) frameNode.setAttribute('message', message) self.message_frame_dict[message] = frame if includeContent: self.addDict(frameNode, "locals", frame.f_locals, document, 2) self.addNode(frameNode, "globals", frame.f_globals, document) def request_frame_document(self, message): frame = self.message_frame_dict[message] doc = getDOMImplementation().createDocument(None, "stack", None) top_element = doc.documentElement if frame: self.addFrame(frame, top_element, doc, includeContent=True) return xmlrpclib.Binary(bz2.compress(doc.toxml())) def getRepr(self, varName, globals, locals): try: return repr(eval(varName, globals, locals)) except: return 'Error: Could not recover value.' def saferepr(self, thing): try: try: return repr(thing) except: return str(type(thing)) except: tp, val, tb = sys.exc_info() #traceback.print_exception(tp, val, tb) return repr(val) # The debugger calls this method when it reaches a breakpoint. def interaction(self, message, frame, info): if _VERBOSE: print 'hit debug side interaction' self._adb._userBreak = False self._currentFrame = frame done = False while not done: try: xml = self.getFrameXML(frame) arg = xmlrpclib.Binary(bz2.compress(xml)) if _VERBOSE: print '============== calling gui side interaction============' self._guiServer.interaction(xmlrpclib.Binary(message), arg, info) if _VERBOSE: print 'after interaction' done = True except: tp, val, tb = sys.exc_info() if True or _VERBOSE: print 'Error contacting GUI server!: ' try: traceback.print_exception(tp, val, tb) except: print "Exception printing traceback", tp, val, tb = sys.exc_info() traceback.print_exception(tp, val, tb) done = False # Block while waiting to be called back from the GUI. Eventually, self._wait will # be set false by a function on this side. Seems pretty lame--I'm surprised it works. self.waitForRPC() def waitForRPC(self): self._wait = True while self._wait : try: if _VERBOSE: print "+++ in harness wait for rpc, before handle_request" self._server.handle_request() if _VERBOSE: print "+++ in harness wait for rpc, after handle_request" except: if _VERBOSE: tp, val, tb = sys.exc_info() print "Got waitForRpc exception : ", repr(tp), ": ", val #time.sleep(0.1) def set_step(self): self._adb.set_step() self._wait = False return "" def set_continue(self): self._adb.set_continue() self._wait = False return "" def set_next(self): self._adb.set_next(self._currentFrame) self._wait = False return "" def set_return(self): self._adb.set_return(self._currentFrame) self._wait = False return "" if __name__ == '__main__': try: harness = DebuggerHarness() harness.run() harness.do_exit(kill=True) except SystemExit: print "Exiting..." except: tp, val, tb = sys.exc_info() traceback.print_exception(tp, val, tb)