|
|
import itertools |
|
|
import linecache |
|
|
import os |
|
|
import re |
|
|
import sys |
|
|
import sysconfig |
|
|
import traceback |
|
|
import typing as t |
|
|
|
|
|
from markupsafe import escape |
|
|
|
|
|
from ..utils import cached_property |
|
|
from .console import Console |
|
|
|
|
|
HEADER = """\ |
|
|
<!doctype html> |
|
|
<html lang=en> |
|
|
<head> |
|
|
<title>%(title)s // Werkzeug Debugger</title> |
|
|
<link rel="stylesheet" href="?__debugger__=yes&cmd=resource&f=style.css"> |
|
|
<link rel="shortcut icon" |
|
|
href="?__debugger__=yes&cmd=resource&f=console.png"> |
|
|
<script src="?__debugger__=yes&cmd=resource&f=debugger.js"></script> |
|
|
<script> |
|
|
var CONSOLE_MODE = %(console)s, |
|
|
EVALEX = %(evalex)s, |
|
|
EVALEX_TRUSTED = %(evalex_trusted)s, |
|
|
SECRET = "%(secret)s"; |
|
|
</script> |
|
|
</head> |
|
|
<body style="background-color: #fff"> |
|
|
<div class="debugger"> |
|
|
""" |
|
|
|
|
|
FOOTER = """\ |
|
|
<div class="footer"> |
|
|
Brought to you by <strong class="arthur">DON'T PANIC</strong>, your |
|
|
friendly Werkzeug powered traceback interpreter. |
|
|
</div> |
|
|
</div> |
|
|
|
|
|
<div class="pin-prompt"> |
|
|
<div class="inner"> |
|
|
<h3>Console Locked</h3> |
|
|
<p> |
|
|
The console is locked and needs to be unlocked by entering the PIN. |
|
|
You can find the PIN printed out on the standard output of your |
|
|
shell that runs the server. |
|
|
<form> |
|
|
<p>PIN: |
|
|
<input type=text name=pin size=14> |
|
|
<input type=submit name=btn value="Confirm Pin"> |
|
|
</form> |
|
|
</div> |
|
|
</div> |
|
|
</body> |
|
|
</html> |
|
|
""" |
|
|
|
|
|
PAGE_HTML = ( |
|
|
HEADER |
|
|
+ """\ |
|
|
<h1>%(exception_type)s</h1> |
|
|
<div class="detail"> |
|
|
<p class="errormsg">%(exception)s</p> |
|
|
</div> |
|
|
<h2 class="traceback">Traceback <em>(most recent call last)</em></h2> |
|
|
%(summary)s |
|
|
<div class="plain"> |
|
|
<p> |
|
|
This is the Copy/Paste friendly version of the traceback. |
|
|
</p> |
|
|
<textarea cols="50" rows="10" name="code" readonly>%(plaintext)s</textarea> |
|
|
</div> |
|
|
<div class="explanation"> |
|
|
The debugger caught an exception in your WSGI application. You can now |
|
|
look at the traceback which led to the error. <span class="nojavascript"> |
|
|
If you enable JavaScript you can also use additional features such as code |
|
|
execution (if the evalex feature is enabled), automatic pasting of the |
|
|
exceptions and much more.</span> |
|
|
</div> |
|
|
""" |
|
|
+ FOOTER |
|
|
+ """ |
|
|
<!-- |
|
|
|
|
|
%(plaintext_cs)s |
|
|
|
|
|
--> |
|
|
""" |
|
|
) |
|
|
|
|
|
CONSOLE_HTML = ( |
|
|
HEADER |
|
|
+ """\ |
|
|
<h1>Interactive Console</h1> |
|
|
<div class="explanation"> |
|
|
In this console you can execute Python expressions in the context of the |
|
|
application. The initial namespace was created by the debugger automatically. |
|
|
</div> |
|
|
<div class="console"><div class="inner">The Console requires JavaScript.</div></div> |
|
|
""" |
|
|
+ FOOTER |
|
|
) |
|
|
|
|
|
SUMMARY_HTML = """\ |
|
|
<div class="%(classes)s"> |
|
|
%(title)s |
|
|
<ul>%(frames)s</ul> |
|
|
%(description)s |
|
|
</div> |
|
|
""" |
|
|
|
|
|
FRAME_HTML = """\ |
|
|
<div class="frame" id="frame-%(id)d"> |
|
|
<h4>File <cite class="filename">"%(filename)s"</cite>, |
|
|
line <em class="line">%(lineno)s</em>, |
|
|
in <code class="function">%(function_name)s</code></h4> |
|
|
<div class="source %(library)s">%(lines)s</div> |
|
|
</div> |
|
|
""" |
|
|
|
|
|
|
|
|
def _process_traceback( |
|
|
exc: BaseException, |
|
|
te: t.Optional[traceback.TracebackException] = None, |
|
|
*, |
|
|
skip: int = 0, |
|
|
hide: bool = True, |
|
|
) -> traceback.TracebackException: |
|
|
if te is None: |
|
|
te = traceback.TracebackException.from_exception(exc, lookup_lines=False) |
|
|
|
|
|
|
|
|
|
|
|
frame_gen = traceback.walk_tb(exc.__traceback__) |
|
|
limit = getattr(sys, "tracebacklimit", None) |
|
|
|
|
|
if limit is not None: |
|
|
if limit < 0: |
|
|
limit = 0 |
|
|
|
|
|
frame_gen = itertools.islice(frame_gen, limit) |
|
|
|
|
|
if skip: |
|
|
frame_gen = itertools.islice(frame_gen, skip, None) |
|
|
del te.stack[:skip] |
|
|
|
|
|
new_stack: t.List[DebugFrameSummary] = [] |
|
|
hidden = False |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for (f, _), fs in zip(frame_gen, te.stack): |
|
|
if hide: |
|
|
hide_value = f.f_locals.get("__traceback_hide__", False) |
|
|
|
|
|
if hide_value in {"before", "before_and_this"}: |
|
|
new_stack = [] |
|
|
hidden = False |
|
|
|
|
|
if hide_value == "before_and_this": |
|
|
continue |
|
|
elif hide_value in {"reset", "reset_and_this"}: |
|
|
hidden = False |
|
|
|
|
|
if hide_value == "reset_and_this": |
|
|
continue |
|
|
elif hide_value in {"after", "after_and_this"}: |
|
|
hidden = True |
|
|
|
|
|
if hide_value == "after_and_this": |
|
|
continue |
|
|
elif hide_value or hidden: |
|
|
continue |
|
|
|
|
|
frame_args: t.Dict[str, t.Any] = { |
|
|
"filename": fs.filename, |
|
|
"lineno": fs.lineno, |
|
|
"name": fs.name, |
|
|
"locals": f.f_locals, |
|
|
"globals": f.f_globals, |
|
|
} |
|
|
|
|
|
if hasattr(fs, "colno"): |
|
|
frame_args["colno"] = fs.colno |
|
|
frame_args["end_colno"] = fs.end_colno |
|
|
|
|
|
new_stack.append(DebugFrameSummary(**frame_args)) |
|
|
|
|
|
|
|
|
|
|
|
while new_stack: |
|
|
module = new_stack[0].global_ns.get("__name__") |
|
|
|
|
|
if module is None: |
|
|
module = new_stack[0].local_ns.get("__name__") |
|
|
|
|
|
if module == "codeop": |
|
|
del new_stack[0] |
|
|
else: |
|
|
break |
|
|
|
|
|
te.stack[:] = new_stack |
|
|
|
|
|
if te.__context__: |
|
|
context_exc = t.cast(BaseException, exc.__context__) |
|
|
te.__context__ = _process_traceback(context_exc, te.__context__, hide=hide) |
|
|
|
|
|
if te.__cause__: |
|
|
cause_exc = t.cast(BaseException, exc.__cause__) |
|
|
te.__cause__ = _process_traceback(cause_exc, te.__cause__, hide=hide) |
|
|
|
|
|
return te |
|
|
|
|
|
|
|
|
class DebugTraceback: |
|
|
__slots__ = ("_te", "_cache_all_tracebacks", "_cache_all_frames") |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
exc: BaseException, |
|
|
te: t.Optional[traceback.TracebackException] = None, |
|
|
*, |
|
|
skip: int = 0, |
|
|
hide: bool = True, |
|
|
) -> None: |
|
|
self._te = _process_traceback(exc, te, skip=skip, hide=hide) |
|
|
|
|
|
def __str__(self) -> str: |
|
|
return f"<{type(self).__name__} {self._te}>" |
|
|
|
|
|
@cached_property |
|
|
def all_tracebacks( |
|
|
self, |
|
|
) -> t.List[t.Tuple[t.Optional[str], traceback.TracebackException]]: |
|
|
out = [] |
|
|
current = self._te |
|
|
|
|
|
while current is not None: |
|
|
if current.__cause__ is not None: |
|
|
chained_msg = ( |
|
|
"The above exception was the direct cause of the" |
|
|
" following exception" |
|
|
) |
|
|
chained_exc = current.__cause__ |
|
|
elif current.__context__ is not None and not current.__suppress_context__: |
|
|
chained_msg = ( |
|
|
"During handling of the above exception, another" |
|
|
" exception occurred" |
|
|
) |
|
|
chained_exc = current.__context__ |
|
|
else: |
|
|
chained_msg = None |
|
|
chained_exc = None |
|
|
|
|
|
out.append((chained_msg, current)) |
|
|
current = chained_exc |
|
|
|
|
|
return out |
|
|
|
|
|
@cached_property |
|
|
def all_frames(self) -> t.List["DebugFrameSummary"]: |
|
|
return [ |
|
|
f for _, te in self.all_tracebacks for f in te.stack |
|
|
] |
|
|
|
|
|
def render_traceback_text(self) -> str: |
|
|
return "".join(self._te.format()) |
|
|
|
|
|
def render_traceback_html(self, include_title: bool = True) -> str: |
|
|
library_frames = [f.is_library for f in self.all_frames] |
|
|
mark_library = 0 < sum(library_frames) < len(library_frames) |
|
|
rows = [] |
|
|
|
|
|
if not library_frames: |
|
|
classes = "traceback noframe-traceback" |
|
|
else: |
|
|
classes = "traceback" |
|
|
|
|
|
for msg, current in reversed(self.all_tracebacks): |
|
|
row_parts = [] |
|
|
|
|
|
if msg is not None: |
|
|
row_parts.append(f'<li><div class="exc-divider">{msg}:</div>') |
|
|
|
|
|
for frame in current.stack: |
|
|
frame = t.cast(DebugFrameSummary, frame) |
|
|
info = f' title="{escape(frame.info)}"' if frame.info else "" |
|
|
row_parts.append(f"<li{info}>{frame.render_html(mark_library)}") |
|
|
|
|
|
rows.append("\n".join(row_parts)) |
|
|
|
|
|
is_syntax_error = issubclass(self._te.exc_type, SyntaxError) |
|
|
|
|
|
if include_title: |
|
|
if is_syntax_error: |
|
|
title = "Syntax Error" |
|
|
else: |
|
|
title = "Traceback <em>(most recent call last)</em>:" |
|
|
else: |
|
|
title = "" |
|
|
|
|
|
exc_full = escape("".join(self._te.format_exception_only())) |
|
|
|
|
|
if is_syntax_error: |
|
|
description = f"<pre class=syntaxerror>{exc_full}</pre>" |
|
|
else: |
|
|
description = f"<blockquote>{exc_full}</blockquote>" |
|
|
|
|
|
return SUMMARY_HTML % { |
|
|
"classes": classes, |
|
|
"title": f"<h3>{title}</h3>", |
|
|
"frames": "\n".join(rows), |
|
|
"description": description, |
|
|
} |
|
|
|
|
|
def render_debugger_html( |
|
|
self, evalex: bool, secret: str, evalex_trusted: bool |
|
|
) -> str: |
|
|
exc_lines = list(self._te.format_exception_only()) |
|
|
plaintext = "".join(self._te.format()) |
|
|
return PAGE_HTML % { |
|
|
"evalex": "true" if evalex else "false", |
|
|
"evalex_trusted": "true" if evalex_trusted else "false", |
|
|
"console": "false", |
|
|
"title": exc_lines[0], |
|
|
"exception": escape("".join(exc_lines)), |
|
|
"exception_type": escape(self._te.exc_type.__name__), |
|
|
"summary": self.render_traceback_html(include_title=False), |
|
|
"plaintext": escape(plaintext), |
|
|
"plaintext_cs": re.sub("-{2,}", "-", plaintext), |
|
|
"secret": secret, |
|
|
} |
|
|
|
|
|
|
|
|
class DebugFrameSummary(traceback.FrameSummary): |
|
|
"""A :class:`traceback.FrameSummary` that can evaluate code in the |
|
|
frame's namespace. |
|
|
""" |
|
|
|
|
|
__slots__ = ( |
|
|
"local_ns", |
|
|
"global_ns", |
|
|
"_cache_info", |
|
|
"_cache_is_library", |
|
|
"_cache_console", |
|
|
) |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
*, |
|
|
locals: t.Dict[str, t.Any], |
|
|
globals: t.Dict[str, t.Any], |
|
|
**kwargs: t.Any, |
|
|
) -> None: |
|
|
super().__init__(locals=None, **kwargs) |
|
|
self.local_ns = locals |
|
|
self.global_ns = globals |
|
|
|
|
|
@cached_property |
|
|
def info(self) -> t.Optional[str]: |
|
|
return self.local_ns.get("__traceback_info__") |
|
|
|
|
|
@cached_property |
|
|
def is_library(self) -> bool: |
|
|
return any( |
|
|
self.filename.startswith((path, os.path.realpath(path))) |
|
|
for path in sysconfig.get_paths().values() |
|
|
) |
|
|
|
|
|
@cached_property |
|
|
def console(self) -> Console: |
|
|
return Console(self.global_ns, self.local_ns) |
|
|
|
|
|
def eval(self, code: str) -> t.Any: |
|
|
return self.console.eval(code) |
|
|
|
|
|
def render_html(self, mark_library: bool) -> str: |
|
|
context = 5 |
|
|
lines = linecache.getlines(self.filename) |
|
|
line_idx = self.lineno - 1 |
|
|
start_idx = max(0, line_idx - context) |
|
|
stop_idx = min(len(lines), line_idx + context + 1) |
|
|
rendered_lines = [] |
|
|
|
|
|
def render_line(line: str, cls: str) -> None: |
|
|
line = line.expandtabs().rstrip() |
|
|
stripped_line = line.strip() |
|
|
prefix = len(line) - len(stripped_line) |
|
|
colno = getattr(self, "colno", 0) |
|
|
end_colno = getattr(self, "end_colno", 0) |
|
|
|
|
|
if cls == "current" and colno and end_colno: |
|
|
arrow = ( |
|
|
f'\n<span class="ws">{" " * prefix}</span>' |
|
|
f'{" " * (colno - prefix)}{"^" * (end_colno - colno)}' |
|
|
) |
|
|
else: |
|
|
arrow = "" |
|
|
|
|
|
rendered_lines.append( |
|
|
f'<pre class="line {cls}"><span class="ws">{" " * prefix}</span>' |
|
|
f"{escape(stripped_line) if stripped_line else ' '}" |
|
|
f"{arrow if arrow else ''}</pre>" |
|
|
) |
|
|
|
|
|
if lines: |
|
|
for line in lines[start_idx:line_idx]: |
|
|
render_line(line, "before") |
|
|
|
|
|
render_line(lines[line_idx], "current") |
|
|
|
|
|
for line in lines[line_idx + 1 : stop_idx]: |
|
|
render_line(line, "after") |
|
|
|
|
|
return FRAME_HTML % { |
|
|
"id": id(self), |
|
|
"filename": escape(self.filename), |
|
|
"lineno": self.lineno, |
|
|
"function_name": escape(self.name), |
|
|
"lines": "\n".join(rendered_lines), |
|
|
"library": "library" if mark_library and self.is_library else "", |
|
|
} |
|
|
|
|
|
|
|
|
def render_console_html(secret: str, evalex_trusted: bool) -> str: |
|
|
return CONSOLE_HTML % { |
|
|
"evalex": "true", |
|
|
"evalex_trusted": "true" if evalex_trusted else "false", |
|
|
"console": "true", |
|
|
"title": "Console", |
|
|
"secret": secret, |
|
|
} |
|
|
|
