Index: django/conf/global_settings.py =================================================================== --- django/conf/global_settings.py (revision 4988) +++ django/conf/global_settings.py (working copy) @@ -11,6 +11,7 @@ DEBUG = False TEMPLATE_DEBUG = False +DEBUGGER_ENABLED = False # Whether to use the "Etag" header. This saves bandwidth but slows down performance. USE_ETAGS = False Index: django/views/debug.py =================================================================== --- django/views/debug.py (revision 4988) +++ django/views/debug.py (working copy) @@ -2,10 +2,15 @@ from django.template import Template, Context, TemplateDoesNotExist from django.utils.html import escape from django.http import HttpResponseServerError, HttpResponseNotFound -import os, re +import sys, os, re, code, threading HIDDEN_SETTINGS = re.compile('SECRET|PASSWORD|PROFANITIES_LIST') +def new_debugger_id(): + import time + import md5 + return md5.new(str(time.time())).hexdigest() + def linebreak_iter(template_source): yield 0 p = template_source.find('\n') @@ -66,6 +71,13 @@ Create a technical server error response. The last three arguments are the values returned from sys.exc_info() and friends. """ + if settings.DEBUGGER_ENABLED: + debugger_id = new_debugger_id() + debugger_enabled = True + frame_storage = console.debug_sessions[debugger_id] = {} + else: + debugger_id = None + debugger_enabled = False template_info = None template_does_not_exist = False loader_debug_info = None @@ -90,11 +102,20 @@ exc_type, exc_value, tb, template_info = get_template_exception_info(exc_type, exc_value, tb) frames = [] while tb is not None: + # support for __traceback_hide__ which is used by a few libraries + # to hide internal frames. + if tb.tb_frame.f_locals.get('__traceback_hide__'): + tb = tb.tb_next + continue + if debugger_enabled: + frame_storage[str(id(tb))] = tb.tb_frame filename = tb.tb_frame.f_code.co_filename function = tb.tb_frame.f_code.co_name lineno = tb.tb_lineno - 1 - pre_context_lineno, pre_context, context_line, post_context = _get_lines_from_file(filename, lineno, 7) - if pre_context_lineno: + loader = tb.tb_frame.f_globals.get('__loader__') + module_name = tb.tb_frame.f_globals.get('__name__') + pre_context_lineno, pre_context, context_line, post_context = _get_lines_from_file(filename, lineno, 7, loader, module_name) + if pre_context_lineno is not None: frames.append({ 'tb': tb, 'filename': filename, @@ -117,6 +138,8 @@ }] t = Template(TECHNICAL_500_TEMPLATE, name='Technical 500 template') c = Context({ + 'debugger_id': debugger_id, + 'debugger_enabled': debugger_enabled, 'exception_type': exc_type.__name__, 'exception_value': exc_value, 'frames': frames, @@ -161,30 +184,146 @@ }) return HttpResponseNotFound(t.render(c), mimetype='text/html') -def _get_lines_from_file(filename, lineno, context_lines): +def _get_lines_from_file(filename, lineno, context_lines, loader=None, module_name=None): """ Returns context_lines before and after lineno from file. Returns (pre_context_lineno, pre_context, context_line, post_context). """ - try: - source = open(filename).readlines() - lower_bound = max(0, lineno - context_lines) - upper_bound = lineno + context_lines + source = None + if loader is not None: + source = loader.get_source(module_name).splitlines() + else: + try: + f = open(filename) + try: + source = f.readlines() + finally: + f.close() + except (OSError, IOError): + pass + if source is None: + return None, [], None, [] - pre_context = [line.strip('\n') for line in source[lower_bound:lineno]] - context_line = source[lineno].strip('\n') - post_context = [line.strip('\n') for line in source[lineno+1:upper_bound]] + lower_bound = max(0, lineno - context_lines) + upper_bound = lineno + context_lines - return lower_bound, pre_context, context_line, post_context - except (OSError, IOError): - return None, [], None, [] + pre_context = [line.strip('\n') for line in source[lower_bound:lineno]] + context_line = source[lineno].strip('\n') + post_context = [line.strip('\n') for line in source[lineno+1:upper_bound]] + return lower_bound, pre_context, context_line, post_context + + +class DebugCapture(object): + """ + Class that wraps sys.stdout in order to get the output + for the debugger. threadsafe but quite slow. + """ + _orig = None + + def __init__(self): + self._buffer = {} + + def install(cls): + if cls._orig: + return + cls._orig = sys.stdout + sys.stdout = cls() + install = classmethod(install) + + def push(self): + from cStringIO import StringIO + tid = threading.currentThread() + self._buffer[tid] = StringIO() + + def release(self): + tid = threading.currentThread() + if tid in self._buffer: + result = self._buffer[tid].getvalue() + del self._buffer[tid] + else: + result = '' + return result + + def write(self, d): + tid = threading.currentThread() + if tid in self._buffer: + self._buffer[tid].write(d) + else: + self._orig.write(d) + + +class PlainDebugger(code.InteractiveInterpreter): + """ + Subclass of the python interactive interpreter that + automatically captures stdout and buffers older input. + """ + + def __init__(self, locals=None, globals=None): + self.globals = globals + code.InteractiveInterpreter.__init__(self, locals) + self.prompt = '>>> ' + self.buffer = [] + + def runsource(self, source): + # installs the debug capture on first access + DebugCapture.install() + prompt = self.prompt + sys.stdout.push() + try: + source_to_eval = ''.join(self.buffer + [source]) + if code.InteractiveInterpreter.runsource(self, + source_to_eval, '', 'single'): + self.prompt = '... ' + self.buffer.append(source) + else: + self.prompt = '>>> ' + del self.buffer[:] + finally: + return prompt + source + sys.stdout.release() + + def runcode(self, code): + try: + exec code in self.globals, self.locals + except: + self.showtraceback() + + def write(self, data): + sys.stdout.write(data) + + +class AjaxDebugger(object): + """ + The AJAX Debugger + """ + + def __init__(self): + self.debug_sessions = {} + self.consoles = {} + + def send(self, debugger, frame, cmd): + if debugger not in self.debug_sessions: + return '!!! expired debugger !!!' + session = self.debug_sessions[debugger] + if frame not in session: + return '!!! unknown frame !!!' + key = '%s|%s' % (debugger, frame) + if key not in self.consoles: + self.consoles[key] = PlainDebugger( + session[frame].f_globals, + session[frame].f_locals + ) + return self.consoles[key].runsource(cmd) + + +console = AjaxDebugger() + # # Templates are embedded in the file so that we know the error handler will # always work even if the template loader is broken. # -TECHNICAL_500_TEMPLATE = """ +TECHNICAL_500_TEMPLATE = r""" @@ -197,6 +336,7 @@ body * * { padding:0; } body { font:small sans-serif; } body>div { border-bottom:1px solid #ddd; } + a { color: #333; } h1 { font-weight:normal; } h2 { margin-bottom:.8em; } h2 span { font-size:80%; color:#666; font-weight:normal; } @@ -212,6 +352,8 @@ table td.code div { overflow:hidden; } table.source th { color:#666; } table.source td { font-family:monospace; white-space:pre; border-bottom:1px solid #eee; } + form.debug { display: block; padding: 10px 20px 10px 40px; } + form.debug input { margin-top: 5px; width: 100%; } ul.traceback { list-style-type:none; } ul.traceback li.frame { margin-bottom:1em; } div.context { margin: 10px 0; } @@ -219,8 +361,8 @@ div.context ol li { font-family:monospace; white-space:pre; color:#666; cursor:pointer; } div.context ol.context-line li { color:black; background-color:#ccc; } div.context ol.context-line li span { float: right; } - div.commands { margin-left: 40px; } - div.commands a { color:black; text-decoration:none; } + ul.commands { margin-left: 40px; padding: 0; list-style: none; } + ul.commands a { color:black; text-decoration:none; } #summary { background: #ffc; } #summary h2 { font-weight: normal; color: #666; } #explanation { background:#eee; } @@ -236,21 +378,23 @@ @@ -314,7 +511,7 @@ Exception Location: - {{ lastframe.filename }} in {{ lastframe.function }}, line {{ lastframe.lineno }} + {{ lastframe.filename|escape }} in {{ lastframe.function|escape }}, line {{ lastframe.lineno }} @@ -361,7 +558,7 @@