added missing file to git
This commit is contained in:
Massimo DiPierro
@@ -1 +1 @@
|
||||
Version 1.99.7 (2012-03-07 15:25:49) dev
|
||||
Version 1.99.7 (2012-03-09 01:59:43) dev
|
||||
|
||||
@@ -0,0 +1,964 @@
|
||||
#!/usr/bin/env python
|
||||
# coding:utf-8
|
||||
|
||||
"Queues(Pipe)-based independent remote client-server Python Debugger"
|
||||
|
||||
__author__ = "Mariano Reingart (reingart@gmail.com)"
|
||||
__copyright__ = "Copyright (C) 2011 Mariano Reingart"
|
||||
__license__ = "LGPL 3.0"
|
||||
__version__ = "1.01b"
|
||||
|
||||
# remote debugger queue-based (jsonrpc-like interface):
|
||||
# - bidirectional communication (request - response calls in both ways)
|
||||
# - request with id == null is a notification (do not send a response)
|
||||
# - request with a value for id is a normal call, wait response
|
||||
# based on idle, inspired by pythonwin implementation, taken many code from pdb
|
||||
|
||||
import bdb
|
||||
import inspect
|
||||
import linecache
|
||||
import os
|
||||
import sys
|
||||
import traceback
|
||||
import cmd
|
||||
import pydoc
|
||||
import threading
|
||||
|
||||
class Qdb(bdb.Bdb):
|
||||
"Qdb Debugger Backend"
|
||||
|
||||
def __init__(self, pipe, redirect_stdio=True, allow_interruptions=False,
|
||||
skip=[__name__]):
|
||||
kwargs = {}
|
||||
if sys.version_info > (2, 7):
|
||||
kwargs['skip'] = skip
|
||||
bdb.Bdb.__init__(self, **kwargs)
|
||||
self.frame = None
|
||||
self.i = 1 # sequential RPC call id
|
||||
self.waiting = False
|
||||
self.pipe = pipe # for communication
|
||||
self._wait_for_mainpyfile = False
|
||||
self._wait_for_breakpoint = False
|
||||
self.mainpyfile = ""
|
||||
self._lineno = None # last listed line numbre
|
||||
# replace system standard input and output (send them thru the pipe)
|
||||
if redirect_stdio:
|
||||
sys.stdin = self
|
||||
sys.stdout = self
|
||||
sys.stderr = self
|
||||
if allow_interruptions:
|
||||
# fake breakpoint to prevent removing trace_dispatch on set_continue
|
||||
self.breaks[None] = []
|
||||
self.allow_interruptions = allow_interruptions
|
||||
self.burst = 0 # do not send notifications ("burst" mode)
|
||||
self.params = {} # optional parameters for interaction
|
||||
|
||||
def pull_actions(self):
|
||||
# receive a remote procedure call from the frontend:
|
||||
# returns True if action processed
|
||||
# None when 'run' notification is received (see 'startup')
|
||||
request = self.pipe.recv()
|
||||
if request.get("method") == 'run':
|
||||
return None
|
||||
response = {'version': '1.1', 'id': request.get('id'),
|
||||
'result': None,
|
||||
'error': None}
|
||||
try:
|
||||
# dispatch message (JSON RPC like)
|
||||
method = getattr(self, request['method'])
|
||||
response['result'] = method.__call__(*request['args'],
|
||||
**request.get('kwargs', {}))
|
||||
except Exception, e:
|
||||
response['error'] = {'code': 0, 'message': str(e)}
|
||||
# send the result for normal method calls, not for notifications
|
||||
if request.get('id'):
|
||||
self.pipe.send(response)
|
||||
return True
|
||||
|
||||
# Override Bdb methods
|
||||
|
||||
def trace_dispatch(self, frame, event, arg):
|
||||
# check for non-interaction rpc (set_breakpoint, interrupt)
|
||||
while self.allow_interruptions and self.pipe.poll():
|
||||
self.pull_actions()
|
||||
# process the frame (see Bdb.trace_dispatch)
|
||||
if self.quitting:
|
||||
return # None
|
||||
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)
|
||||
return self.trace_dispatch
|
||||
|
||||
def user_call(self, frame, argument_list):
|
||||
"""This method is called when there is the remote possibility
|
||||
that we ever need to stop in this function."""
|
||||
if self._wait_for_mainpyfile or self._wait_for_breakpoint:
|
||||
return
|
||||
if self.stop_here(frame):
|
||||
self.interaction(frame, None)
|
||||
|
||||
def user_line(self, frame):
|
||||
"""This function is called when we stop or break at this line."""
|
||||
if self._wait_for_mainpyfile:
|
||||
if (not self.canonic(frame.f_code.co_filename).startswith(self.mainpyfile)
|
||||
or frame.f_lineno<= 0):
|
||||
return
|
||||
self._wait_for_mainpyfile = 0
|
||||
if self._wait_for_breakpoint:
|
||||
if not self.break_here(frame):
|
||||
return
|
||||
self._wait_for_breakpoint = 0
|
||||
self.interaction(frame)
|
||||
|
||||
def user_exception(self, frame, info):
|
||||
"""This function is called if an exception occurs,
|
||||
but only if we are to stop at or just below this level."""
|
||||
if self._wait_for_mainpyfile or self._wait_for_breakpoint:
|
||||
return
|
||||
extype, exvalue, trace = info
|
||||
# pre-process stack trace as it isn't pickeable (cannot be sent pure)
|
||||
msg = ''.join(traceback.format_exception(extype, exvalue, trace))
|
||||
trace = traceback.extract_tb(trace)
|
||||
title = traceback.format_exception_only(extype, exvalue)[0]
|
||||
# send an Exception notification
|
||||
msg = {'method': 'exception',
|
||||
'args': (title, extype.__name__, exvalue, trace, msg),
|
||||
'id': None}
|
||||
self.pipe.send(msg)
|
||||
self.interaction(frame, info)
|
||||
|
||||
def run(self, code, interp=None, *args, **kwargs):
|
||||
try:
|
||||
return bdb.Bdb.run(self, code, *args, **kwargs)
|
||||
finally:
|
||||
pass
|
||||
|
||||
def runcall(self, function, interp=None, *args, **kwargs):
|
||||
try:
|
||||
self.interp = interp
|
||||
return bdb.Bdb.runcall(self, function, *args, **kwargs)
|
||||
finally:
|
||||
pass
|
||||
|
||||
def _runscript(self, filename):
|
||||
# The script has to run in __main__ namespace (clear it)
|
||||
import __main__
|
||||
import imp
|
||||
__main__.__dict__.clear()
|
||||
__main__.__dict__.update({"__name__" : "__main__",
|
||||
"__file__" : filename,
|
||||
"__builtins__": __builtins__,
|
||||
"imp" : imp, # need for run
|
||||
})
|
||||
|
||||
# avoid stopping before we reach the main script
|
||||
self._wait_for_mainpyfile = 1
|
||||
self.mainpyfile = self.canonic(filename)
|
||||
self._user_requested_quit = 0
|
||||
statement = 'imp.load_source("__main__", "%s")' % filename
|
||||
# notify and wait frontend to set initial params and breakpoints
|
||||
self.pipe.send({'method': 'startup', 'args': (__version__, )})
|
||||
while self.pull_actions() is not None:
|
||||
pass
|
||||
self.run(statement)
|
||||
|
||||
# General interaction function
|
||||
|
||||
def interaction(self, frame, info=None):
|
||||
# chache frame locals to ensure that modifications are not overwritten
|
||||
self.frame_locals = frame and frame.f_locals or {}
|
||||
# extract current filename and line number
|
||||
code, lineno = frame.f_code, frame.f_lineno
|
||||
filename = code.co_filename
|
||||
basename = os.path.basename(filename)
|
||||
message = "%s:%s" % (basename, lineno)
|
||||
if code.co_name != "?":
|
||||
message = "%s: %s()" % (message, code.co_name)
|
||||
|
||||
# wait user events
|
||||
self.waiting = True
|
||||
self.frame = frame
|
||||
try:
|
||||
while self.waiting:
|
||||
# sync_source_line()
|
||||
if frame and filename[:1] + filename[-1:] != "<>" and os.path.exists(filename):
|
||||
line = linecache.getline(filename, self.frame.f_lineno,
|
||||
self.frame.f_globals)
|
||||
else:
|
||||
line = ""
|
||||
# send the notification (debug event) - DOESN'T WAIT RESPONSE
|
||||
self.burst -= 1
|
||||
if self.burst < 0:
|
||||
kwargs = {}
|
||||
if self.params.get('call_stack'):
|
||||
kwargs['call_stack'] = self.do_where()
|
||||
if self.params.get('environment'):
|
||||
kwargs['environment'] = self.do_environment()
|
||||
self.pipe.send({'method': 'interaction', 'id': None,
|
||||
'args': (filename, self.frame.f_lineno, line),
|
||||
'kwargs': kwargs})
|
||||
|
||||
self.pull_actions()
|
||||
|
||||
finally:
|
||||
self.waiting = False
|
||||
self.frame = None
|
||||
|
||||
def do_debug(self, mainpyfile=None, wait_breakpoint=1):
|
||||
self.reset()
|
||||
if not wait_breakpoint or mainpyfile:
|
||||
self._wait_for_mainpyfile = 1
|
||||
if not mainpyfile:
|
||||
frame = sys._getframe().f_back
|
||||
mainpyfile = frame.f_code.co_filename
|
||||
self.mainpyfile = self.canonic(mainpyfile)
|
||||
self._wait_for_breakpoint = wait_breakpoint
|
||||
sys.settrace(self.trace_dispatch)
|
||||
|
||||
def set_trace(self, frame=None):
|
||||
# start debugger interaction immediatelly
|
||||
if frame is None:
|
||||
frame = sys._getframe().f_back
|
||||
self._wait_for_mainpyfile = frame.f_code.co_filename
|
||||
self._wait_for_breakpoint = 0
|
||||
bdb.Bdb.set_trace(self, frame)
|
||||
|
||||
# Command definitions, called by interaction()
|
||||
|
||||
def do_continue(self):
|
||||
self.set_continue()
|
||||
self.waiting = False
|
||||
|
||||
def do_step(self):
|
||||
self.set_step()
|
||||
self.waiting = False
|
||||
|
||||
def do_return(self):
|
||||
self.set_return(self.frame)
|
||||
self.waiting = False
|
||||
|
||||
def do_next(self):
|
||||
self.set_next(self.frame)
|
||||
self.waiting = False
|
||||
|
||||
def interrupt(self):
|
||||
self.set_step()
|
||||
|
||||
def do_quit(self):
|
||||
self.set_quit()
|
||||
self.waiting = False
|
||||
|
||||
def do_jump(self, lineno):
|
||||
arg = int(lineno)
|
||||
try:
|
||||
self.frame.f_lineno = arg
|
||||
return arg
|
||||
except ValueError, e:
|
||||
print '*** Jump failed:', e
|
||||
return False
|
||||
|
||||
def do_list(self, arg):
|
||||
last = None
|
||||
if arg:
|
||||
if isinstance(arg, tuple):
|
||||
first, last = arg
|
||||
else:
|
||||
first = arg
|
||||
elif not self._lineno:
|
||||
first = max(1, self.frame.f_lineno - 5)
|
||||
else:
|
||||
first = self._lineno + 1
|
||||
if last is None:
|
||||
last = first + 10
|
||||
filename = self.frame.f_code.co_filename
|
||||
breaklist = self.get_file_breaks(filename)
|
||||
lines = []
|
||||
for lineno in range(first, last+1):
|
||||
line = linecache.getline(filename, lineno,
|
||||
self.frame.f_globals)
|
||||
if not line:
|
||||
lines.append((filename, lineno, '', current, "<EOF>\n"))
|
||||
break
|
||||
else:
|
||||
breakpoint = "B" if lineno in breaklist else ""
|
||||
current = "->" if self.frame.f_lineno == lineno else ""
|
||||
lines.append((filename, lineno, breakpoint, current, line))
|
||||
self._lineno = lineno
|
||||
return lines
|
||||
|
||||
def do_read(self, filename):
|
||||
return open(filename, "Ur").read()
|
||||
|
||||
def do_set_breakpoint(self, filename, lineno, temporary=0, cond=None):
|
||||
return self.set_break(filename, int(lineno), temporary, cond)
|
||||
|
||||
def do_list_breakpoint(self):
|
||||
breaks = []
|
||||
if self.breaks: # There's at least one
|
||||
for bp in bdb.Breakpoint.bpbynumber:
|
||||
if bp:
|
||||
breaks.append((bp.number, bp.file, bp.line,
|
||||
bp.temporary, bp.enabled, bp.hits, bp.cond, ))
|
||||
return breaks
|
||||
|
||||
def do_clear_breakpoint(self, filename, lineno):
|
||||
self.clear_break(filename, lineno)
|
||||
|
||||
def do_clear_file_breakpoints(self, filename):
|
||||
self.clear_all_file_breaks(filename)
|
||||
|
||||
def do_clear(self, arg):
|
||||
# required by BDB to remove temp breakpoints!
|
||||
err = self.clear_bpbynumber(arg)
|
||||
if err:
|
||||
print '*** DO_CLEAR failed', err
|
||||
|
||||
def do_eval(self, arg, safe=True):
|
||||
ret = eval(arg, self.frame.f_globals,
|
||||
self.frame_locals)
|
||||
if safe:
|
||||
ret = pydoc.cram(repr(ret), 255)
|
||||
return ret
|
||||
|
||||
def do_exec(self, arg):
|
||||
locals = self.frame_locals
|
||||
globals = self.frame.f_globals
|
||||
code = compile(arg + '\n', '<stdin>', 'single')
|
||||
save_displayhook = sys.displayhook
|
||||
self.displayhook_value = None
|
||||
try:
|
||||
sys.displayhook = self.displayhook
|
||||
exec code in globals, locals
|
||||
finally:
|
||||
sys.displayhook = save_displayhook
|
||||
return self.displayhook_value
|
||||
|
||||
def do_where(self):
|
||||
"print_stack_trace"
|
||||
stack, curindex = self.get_stack(self.frame, None)
|
||||
lines = []
|
||||
for frame, lineno in stack:
|
||||
filename = frame.f_code.co_filename
|
||||
line = linecache.getline(filename, lineno)
|
||||
lines.append((filename, lineno, "", "", line, ))
|
||||
return lines
|
||||
|
||||
def do_environment(self):
|
||||
"return current frame local and global environment"
|
||||
env = {'locals': {}, 'globals': {}}
|
||||
# converts the frame global and locals to a short text representation:
|
||||
if self.frame:
|
||||
for name, value in self.frame_locals.items():
|
||||
env['locals'][name] = pydoc.cram(repr(value), 255), repr(type(value))
|
||||
for name, value in self.frame.f_globals.items():
|
||||
env['globals'][name] = pydoc.cram(repr(value), 20), repr(type(value))
|
||||
return env
|
||||
|
||||
def get_autocomplete_list(self, expression):
|
||||
"Return list of auto-completion options for expression"
|
||||
try:
|
||||
obj = self.do_eval(expression)
|
||||
except:
|
||||
return []
|
||||
else:
|
||||
return dir(obj)
|
||||
|
||||
def get_call_tip(self, expression):
|
||||
"Return list of auto-completion options for expression"
|
||||
try:
|
||||
obj = self.do_eval(expression)
|
||||
except Exception, e:
|
||||
return ('', '', str(e))
|
||||
else:
|
||||
name = ''
|
||||
try:
|
||||
name = obj.__name__
|
||||
except AttributeError:
|
||||
pass
|
||||
argspec = ''
|
||||
drop_self = 0
|
||||
f = None
|
||||
try:
|
||||
if inspect.isbuiltin(obj):
|
||||
pass
|
||||
elif inspect.ismethod(obj):
|
||||
# Get the function from the object
|
||||
f = obj.im_func
|
||||
drop_self = 1
|
||||
elif inspect.isclass(obj):
|
||||
# Get the __init__ method function for the class.
|
||||
if hasattr(obj, '__init__'):
|
||||
f = obj.__init__.im_func
|
||||
else:
|
||||
for base in object.__bases__:
|
||||
if hasattr(base, '__init__'):
|
||||
f = base.__init__.im_func
|
||||
break
|
||||
if f is not None:
|
||||
drop_self = 1
|
||||
elif callable(obj):
|
||||
# use the obj as a function by default
|
||||
f = obj
|
||||
# Get the __call__ method instead.
|
||||
f = obj.__call__.im_func
|
||||
drop_self = 0
|
||||
except AttributeError:
|
||||
pass
|
||||
if f:
|
||||
argspec = apply(inspect.formatargspec, inspect.getargspec(f))
|
||||
doc = ''
|
||||
if callable(obj):
|
||||
try:
|
||||
doc = inspect.getdoc(obj)
|
||||
except:
|
||||
pass
|
||||
return (name, argspec[1:-1], doc.strip())
|
||||
|
||||
def set_burst(self, val):
|
||||
"Set burst mode -multiple command count- (shut up notifications)"
|
||||
self.burst = val
|
||||
|
||||
def set_params(self, params):
|
||||
"Set parameters for interaction"
|
||||
self.params.update(params)
|
||||
|
||||
def displayhook(self, obj):
|
||||
"""Custom displayhook for the do_exec which prevents
|
||||
assignment of the _ variable in the builtins.
|
||||
"""
|
||||
self.displayhook_value = repr(obj)
|
||||
|
||||
def reset(self):
|
||||
bdb.Bdb.reset(self)
|
||||
self.waiting = False
|
||||
self.frame = None
|
||||
|
||||
def post_mortem(self, t=None):
|
||||
# handling the default
|
||||
if t is None:
|
||||
# sys.exc_info() returns (type, value, traceback) if an exception is
|
||||
# being handled, otherwise it returns None
|
||||
t = sys.exc_info()[2]
|
||||
if t is None:
|
||||
raise ValueError("A valid traceback must be passed if no "
|
||||
"exception is being handled")
|
||||
self.reset()
|
||||
# get last frame:
|
||||
while t is not None:
|
||||
frame = t.tb_frame
|
||||
t = t.tb_next
|
||||
code, lineno = frame.f_code, frame.f_lineno
|
||||
filename = code.co_filename
|
||||
line = linecache.getline(filename, lineno)
|
||||
#(filename, lineno, "", current, line, )}
|
||||
|
||||
self.interaction(frame)
|
||||
|
||||
# console file-like object emulation
|
||||
def readline(self):
|
||||
"Replacement for stdin.readline()"
|
||||
msg = {'method': 'readline', 'args': (), 'id': self.i}
|
||||
self.pipe.send(msg)
|
||||
msg = self.pipe.recv()
|
||||
self.i += 1
|
||||
return msg['result']
|
||||
|
||||
def readlines(self):
|
||||
"Replacement for stdin.readlines()"
|
||||
lines = []
|
||||
while lines[-1:] != ['\n']:
|
||||
lines.append(self.readline())
|
||||
return lines
|
||||
|
||||
def write(self, text):
|
||||
"Replacement for stdout.write()"
|
||||
msg = {'method': 'write', 'args': (text, ), 'id': None}
|
||||
self.pipe.send(msg)
|
||||
|
||||
def writelines(self, l):
|
||||
map(self.write, l)
|
||||
|
||||
def flush(self):
|
||||
pass
|
||||
|
||||
def isatty(self):
|
||||
return 0
|
||||
|
||||
|
||||
class QueuePipe(object):
|
||||
"Simulated pipe for threads (using two queues)"
|
||||
|
||||
def __init__(self, name, in_queue, out_queue):
|
||||
self.__name = name
|
||||
self.in_queue = in_queue
|
||||
self.out_queue = out_queue
|
||||
|
||||
def send(self, data):
|
||||
self.out_queue.put(data, block=True)
|
||||
|
||||
def recv(self, count=None, timeout=None):
|
||||
data = self.in_queue.get(block=True, timeout=timeout)
|
||||
return data
|
||||
|
||||
def poll(self, timeout=None):
|
||||
return not self.in_queue.empty()
|
||||
|
||||
def close(self):
|
||||
pass
|
||||
|
||||
|
||||
class RPCError(RuntimeError):
|
||||
"Remote Error (not user exception)"
|
||||
pass
|
||||
|
||||
|
||||
class Frontend(object):
|
||||
"Qdb generic Frontend interface"
|
||||
|
||||
def __init__(self, pipe):
|
||||
self.i = 1
|
||||
self.pipe = pipe
|
||||
self.notifies = []
|
||||
self.read_lock = threading.RLock()
|
||||
self.write_lock = threading.RLock()
|
||||
|
||||
def recv(self):
|
||||
self.read_lock.acquire()
|
||||
try:
|
||||
return self.pipe.recv()
|
||||
finally:
|
||||
self.read_lock.release()
|
||||
|
||||
def send(self, data):
|
||||
self.write_lock.acquire()
|
||||
try:
|
||||
return self.pipe.send(data)
|
||||
finally:
|
||||
self.write_lock.release()
|
||||
|
||||
def startup(self):
|
||||
self.send({'method': 'run', 'args': (), 'id': None})
|
||||
|
||||
def interaction(self, filename, lineno, line, *kwargs):
|
||||
raise NotImplementedError
|
||||
|
||||
def exception(self, title, extype, exvalue, trace, request):
|
||||
"Show a user_exception"
|
||||
raise NotImplementedError
|
||||
|
||||
def write(self, text):
|
||||
"Console output (print)"
|
||||
raise NotImplementedError
|
||||
|
||||
def readline(self, text):
|
||||
"Console input/rawinput"
|
||||
raise NotImplementedError
|
||||
|
||||
def run(self):
|
||||
"Main method dispatcher (infinite loop)"
|
||||
if self.pipe:
|
||||
if not self.notifies:
|
||||
# wait for a message...
|
||||
request = self.recv()
|
||||
else:
|
||||
# process an asyncronus notification received earlier
|
||||
request = self.notifies.pop(0)
|
||||
return self.process_message(request)
|
||||
|
||||
def process_message(self, request):
|
||||
if request:
|
||||
result = None
|
||||
if request.get("error"):
|
||||
# it is not supposed to get an error here
|
||||
# it should be raised by the method call
|
||||
raise RPCError(res['error']['message'])
|
||||
elif request.get('method') == 'interaction':
|
||||
self.interaction(*request.get("args"), **request.get("kwargs"))
|
||||
elif request.get('method') == 'startup':
|
||||
self.startup()
|
||||
elif request.get('method') == 'exception':
|
||||
self.exception(*request['args'])
|
||||
elif request.get('method') == 'write':
|
||||
self.write(*request.get("args"))
|
||||
elif request.get('method') == 'readline':
|
||||
result = self.readline()
|
||||
if result:
|
||||
response = {'version': '1.1', 'id': request.get('id'),
|
||||
'result': result,
|
||||
'error': None}
|
||||
self.send(response)
|
||||
return True
|
||||
|
||||
def call(self, method, *args):
|
||||
"Actually call the remote method (inside the thread)"
|
||||
req = {'method': method, 'args': args, 'id': self.i}
|
||||
self.send(req)
|
||||
self.i += 1 # increment the id
|
||||
while 1:
|
||||
# wait until command acknowledge (response id match the request)
|
||||
res = self.recv()
|
||||
if 'id' not in res or not res['id']:
|
||||
# nested notification received (i.e. write)! process it!
|
||||
self.process_message(res)
|
||||
elif 'result' not in res:
|
||||
# nested request received (i.e. readline)! process it!
|
||||
self.process_message(res)
|
||||
elif long(req['id']) != long(res['id']):
|
||||
print "DEBUGGER wrong packet received: expecting id", req['id'], res['id']
|
||||
# protocol state is unknown
|
||||
elif 'error' in res and res['error']:
|
||||
raise RPCError(res['error']['message'])
|
||||
else:
|
||||
return res['result']
|
||||
|
||||
def do_step(self, arg=None):
|
||||
"Execute the current line, stop at the first possible occasion"
|
||||
self.call('do_step')
|
||||
|
||||
def do_next(self, arg=None):
|
||||
"Execute the current line, do not stop at function calls"
|
||||
self.call('do_next')
|
||||
|
||||
def do_continue(self, arg=None):
|
||||
"Continue execution, only stop when a breakpoint is encountered."
|
||||
self.call('do_continue')
|
||||
|
||||
def do_return(self, arg=None):
|
||||
"Continue execution until the current function returns"
|
||||
self.call('do_return')
|
||||
|
||||
def do_jump(self, arg):
|
||||
"Set the next line that will be executed."
|
||||
res = self.call('do_jump', arg)
|
||||
print res
|
||||
|
||||
def do_where(self, arg=None):
|
||||
"Print a stack trace, with the most recent frame at the bottom."
|
||||
return self.call('do_where')
|
||||
|
||||
def do_quit(self, arg=None):
|
||||
"Quit from the debugger. The program being executed is aborted."
|
||||
self.call('do_quit')
|
||||
|
||||
def do_eval(self, expr):
|
||||
"Inspect the value of the expression"
|
||||
return self.call('do_eval', expr)
|
||||
|
||||
def do_environment(self):
|
||||
"List all the locals and globals variables (string representation)"
|
||||
return self.call('do_environment')
|
||||
|
||||
def do_list(self, arg=None):
|
||||
"List source code for the current file"
|
||||
return self.call('do_list', arg)
|
||||
|
||||
def do_read(self, filename):
|
||||
"Read and send a local filename"
|
||||
return self.call('do_read', filename)
|
||||
|
||||
def do_set_breakpoint(self, filename, lineno, temporary=0, cond=None):
|
||||
"Set a breakpoint at filename:breakpoint"
|
||||
self.call('do_set_breakpoint', filename, lineno, temporary, cond)
|
||||
|
||||
def do_clear_breakpoint(self, filename, lineno):
|
||||
"Remove a breakpoint at filename:breakpoint"
|
||||
self.call('do_clear_breakpoint', filename, lineno)
|
||||
|
||||
def do_clear_file_breakpoints(self, filename):
|
||||
"Remove all breakpoints at filename"
|
||||
self.call('do_clear_breakpoints', filename, lineno)
|
||||
|
||||
def do_list_breakpoint(self):
|
||||
"List all breakpoints"
|
||||
return self.call('do_list_breakpoint')
|
||||
|
||||
def do_exec(self, statement):
|
||||
return self.call('do_exec', statement)
|
||||
|
||||
def get_autocomplete_list(self, expression):
|
||||
return self.call('get_autocomplete_list', expression)
|
||||
|
||||
def get_call_tip(self, expression):
|
||||
return self.call('get_call_tip', expression)
|
||||
|
||||
def interrupt(self):
|
||||
"Immediately stop at the first possible occasion (outside interaction)"
|
||||
# this is a notification!, do not expect a response
|
||||
req = {'method': 'interrupt', 'args': ()}
|
||||
self.send(req)
|
||||
|
||||
def set_burst(self, value):
|
||||
req = {'method': 'set_burst', 'args': (value, )}
|
||||
self.send(req)
|
||||
|
||||
def set_params(self, params):
|
||||
req = {'method': 'set_params', 'args': (params, )}
|
||||
self.send(req)
|
||||
|
||||
|
||||
class Cli(Frontend, cmd.Cmd):
|
||||
"Qdb Front-end command line interface"
|
||||
|
||||
def __init__(self, pipe, completekey='tab', stdin=None, stdout=None, skip=None):
|
||||
cmd.Cmd.__init__(self, completekey, stdin, stdout)
|
||||
Frontend.__init__(self, pipe)
|
||||
|
||||
# redefine Frontend methods:
|
||||
|
||||
def run(self):
|
||||
while 1:
|
||||
try:
|
||||
Frontend.run(self)
|
||||
except KeyboardInterrupt:
|
||||
print "Interupting..."
|
||||
self.interrupt()
|
||||
|
||||
def interaction(self, filename, lineno, line):
|
||||
print "> %s(%d)\n-> %s" % (filename, lineno, line),
|
||||
self.filename = filename
|
||||
self.cmdloop()
|
||||
|
||||
def exception(self, title, extype, exvalue, trace, request):
|
||||
print "=" * 80
|
||||
print "Exception", title
|
||||
print request
|
||||
print "-" * 80
|
||||
|
||||
def write(self, text):
|
||||
print text,
|
||||
|
||||
def readline(self):
|
||||
return raw_input()
|
||||
|
||||
def postcmd(self, stop, line):
|
||||
return not line.startswith("h") # stop
|
||||
|
||||
do_h = cmd.Cmd.do_help
|
||||
|
||||
do_s = Frontend.do_step
|
||||
do_n = Frontend.do_next
|
||||
do_c = Frontend.do_continue
|
||||
do_r = Frontend.do_return
|
||||
do_j = Frontend.do_jump
|
||||
do_q = Frontend.do_quit
|
||||
|
||||
def do_eval(self, args):
|
||||
"Inspect the value of the expression"
|
||||
print Frontend.do_eval(self, args)
|
||||
|
||||
def do_list(self, args):
|
||||
"List source code for the current file"
|
||||
lines = Frontend.do_list(self, eval(args, {}, {}) if args else None)
|
||||
self.print_lines(lines)
|
||||
|
||||
def do_where(self, args):
|
||||
"Print a stack trace, with the most recent frame at the bottom."
|
||||
lines = Frontend.do_where(self)
|
||||
self.print_lines(lines)
|
||||
|
||||
def do_environment(self, args=None):
|
||||
env = Frontend.do_environment(self)
|
||||
for key in env:
|
||||
print "=" * 78
|
||||
print key.capitalize()
|
||||
print "-" * 78
|
||||
for name, value in env[key].items():
|
||||
print "%-12s = %s" % (name, value)
|
||||
|
||||
def do_list_breakpoint(self, arg=None):
|
||||
"List all breakpoints"
|
||||
breaks = Frontend.do_list_breakpoint(self)
|
||||
print "Num File Line Temp Enab Hits Cond"
|
||||
for bp in breaks:
|
||||
print '%-4d%-30s%4d %4s %4s %4d %s' % bp
|
||||
print
|
||||
|
||||
def do_set_breakpoint(self, arg):
|
||||
"Set a breakpoint at filename:breakpoint"
|
||||
if arg:
|
||||
if ':' in arg:
|
||||
args = arg.split(":")
|
||||
else:
|
||||
args = (self.filename, arg)
|
||||
Frontend.do_set_breakpoint(self, *args)
|
||||
else:
|
||||
self.do_list_breakpoint()
|
||||
|
||||
do_b = do_set_breakpoint
|
||||
do_l = do_list
|
||||
do_p = do_eval
|
||||
do_w = do_where
|
||||
do_e = do_environment
|
||||
|
||||
def default(self, line):
|
||||
"Default command"
|
||||
if line[:1] == '!':
|
||||
print self.do_exec(line[1:])
|
||||
else:
|
||||
print "*** Unknown command: ", line
|
||||
|
||||
def print_lines(self, lines):
|
||||
for filename, lineno, bp, current, source in lines:
|
||||
print "%s:%4d%s%s\t%s" % (filename, lineno, bp, current, source),
|
||||
print
|
||||
|
||||
|
||||
def test():
|
||||
def f(pipe):
|
||||
print "creating debugger"
|
||||
qdb = Qdb(pipe=pipe, redirect_stdio=False)
|
||||
print "set trace"
|
||||
|
||||
my_var = "Mariano!"
|
||||
qdb.set_trace()
|
||||
print "hello world!"
|
||||
print "good by!"
|
||||
saraza
|
||||
|
||||
if '--process' in sys.argv:
|
||||
from multiprocessing import Process, Pipe
|
||||
pipe, child_conn = Pipe()
|
||||
p = Process(target=f, args=(child_conn,))
|
||||
else:
|
||||
from threading import Thread
|
||||
from Queue import Queue
|
||||
parent_queue, child_queue = Queue(), Queue()
|
||||
front_conn = QueuePipe("parent", parent_queue, child_queue)
|
||||
child_conn = QueuePipe("child", child_queue, parent_queue)
|
||||
p = Thread(target=f, args=(child_conn,))
|
||||
|
||||
p.start()
|
||||
import time
|
||||
|
||||
class Test(Frontend):
|
||||
def interaction(self, *args):
|
||||
print "interaction!", args
|
||||
def exception(self, *args):
|
||||
print "exception", args
|
||||
#raise RuntimeError("exception %s" % repr(args))
|
||||
|
||||
qdb = Test(front_conn)
|
||||
time.sleep(5)
|
||||
|
||||
while 1:
|
||||
print "running..."
|
||||
Frontend.run(qdb)
|
||||
time.sleep(1)
|
||||
print "do_next"
|
||||
qdb.do_next()
|
||||
p.join()
|
||||
|
||||
|
||||
def connect(host="localhost", port=6000, authkey='secret password'):
|
||||
"Connect to a running debugger backend"
|
||||
|
||||
address = (host, port)
|
||||
from multiprocessing.connection import Client
|
||||
|
||||
print "qdb debugger fronted: waiting for connection to", address
|
||||
conn = Client(address, authkey=authkey)
|
||||
try:
|
||||
Cli(conn).run()
|
||||
except EOFError:
|
||||
pass
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
def main(host='localhost', port=6000, authkey='secret password'):
|
||||
"Debug a script and accept a remote frontend"
|
||||
|
||||
if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"):
|
||||
print "usage: pdb.py scriptfile [arg] ..."
|
||||
sys.exit(2)
|
||||
|
||||
mainpyfile = sys.argv[1] # Get script filename
|
||||
if not os.path.exists(mainpyfile):
|
||||
print 'Error:', mainpyfile, 'does not exist'
|
||||
sys.exit(1)
|
||||
|
||||
del sys.argv[0] # Hide "pdb.py" from argument list
|
||||
|
||||
# Replace pdb's dir with script's dir in front of module search path.
|
||||
sys.path[0] = os.path.dirname(mainpyfile)
|
||||
|
||||
from multiprocessing.connection import Listener
|
||||
address = (host, port) # family is deduced to be 'AF_INET'
|
||||
listener = Listener(address, authkey=authkey)
|
||||
print "qdb debugger backend: waiting for connection at", address
|
||||
conn = listener.accept()
|
||||
print 'qdb debugger backend: connected to', listener.last_accepted
|
||||
|
||||
# create the backend
|
||||
qdb = Qdb(conn, redirect_stdio=True, allow_interruptions=True)
|
||||
try:
|
||||
print "running", mainpyfile
|
||||
qdb._runscript(mainpyfile)
|
||||
print "The program finished"
|
||||
except SystemExit:
|
||||
# In most cases SystemExit does not warrant a post-mortem session.
|
||||
print "The program exited via sys.exit(). Exit status: ",
|
||||
print sys.exc_info()[1]
|
||||
raise
|
||||
except:
|
||||
raise
|
||||
|
||||
conn.close()
|
||||
listener.close()
|
||||
|
||||
|
||||
qdb = None
|
||||
def set_trace(host='localhost', port=6000, authkey='secret password'):
|
||||
"Simplified interface to debug running programs"
|
||||
global qdb, listener, conn
|
||||
|
||||
from multiprocessing.connection import Listener
|
||||
# only create it if not currently instantiated
|
||||
if not qdb:
|
||||
address = (host, port) # family is deduced to be 'AF_INET'
|
||||
listener = Listener(address, authkey=authkey)
|
||||
conn = listener.accept()
|
||||
|
||||
# create the backend
|
||||
qdb = Qdb(conn)
|
||||
# start debugger backend:
|
||||
qdb.set_trace()
|
||||
|
||||
|
||||
def quit():
|
||||
"Remove trace and quit"
|
||||
global qdb, listener, conn
|
||||
if qdb:
|
||||
sys.settrace(None)
|
||||
qdb = None
|
||||
if conn:
|
||||
conn.close()
|
||||
conn = None
|
||||
if listener:
|
||||
listener.close()
|
||||
listener = None
|
||||
|
||||
if __name__ == '__main__':
|
||||
# When invoked as main program:
|
||||
if '--test' in sys.argv:
|
||||
test()
|
||||
# Check environment for configuration parameters:
|
||||
kwargs = {}
|
||||
for param in 'host', 'port', 'authkey':
|
||||
if 'QDB_%s' % param.upper() in os.environ:
|
||||
kwargs[param] = os.environ['QDB_%s' % param.upper()]
|
||||
|
||||
if not sys.argv[1:]:
|
||||
# connect to a remote debbuger
|
||||
connect(**kwargs)
|
||||
else:
|
||||
# start the debugger on a script
|
||||
# reimport as global __main__ namespace is destroyed
|
||||
import qdb
|
||||
qdb.main(**kwargs)
|
||||
|
||||
Reference in New Issue
Block a user