def connectionLost(self):
process.Process.connectionLost(self)
if self.handling_headers:
self.request.write(
error.ErrorPage(
http.INTERNAL_SERVER_ERROR, "CGI Script Error",
"Premature end of script headers; errors follow:<hr>" +
html.PRE(self.errortext) + "<hr>" +
html.PRE(self.headertext) + "<hr>").render(self.request))
self.request.finish()
def display(self, request):
tm = []
flip = 0
namespace = {}
self.prePresent(request)
self.addVariables(namespace, request)
# This variable may not be obscured...
namespace['request'] = request
namespace['self'] = self
for elem in self.tmpl:
flip = not flip
if flip:
if elem:
tm.append(elem)
else:
try:
x = eval(elem, namespace, namespace)
except:
io = StringIO()
io.write("Traceback evaluating code in %s: %s\n\n" %
(str(self.__class__), elem))
traceback.print_exc(file=io)
tm.append(html.PRE(io.getvalue()))
else:
if isinstance(x, types.ListType):
tm.extend(x)
elif isinstance(x, Widget):
val = x.display(request)
tm.extend(val)
else:
# Only two allowed types here should be deferred and
# string.
tm.append(x)
return tm
def failed(self, expt):
self.request.write(
error.ErrorPage(http.INTERNAL_SERVER_ERROR,
"Server Connection Lost",
"Connection to distributed server lost:" +
html.PRE(expt)).
render(self.request))
self.request.finish()
def failed(self, failure):
#XXX: Argh. FIXME.
failure = str(failure)
self.request.write(
error.ErrorPage(
http.INTERNAL_SERVER_ERROR, "Server Connection Lost",
"Connection to distributed server lost:" +
html.PRE(failure)).render(self.request))
self.request.finish()
log.msg(failure)
def display(self, request):
"""Produce a list containing a single string.
"""
io = StringIO()
try:
result = self.stream(io.write, request)
if result is not None:
return result
return [io.getvalue()]
except:
io = StringIO()
traceback.print_exc(file=io)
return [html.PRE(io.getvalue())]
def reallyRender(self, request):
# it's authenticated already...
try:
res = self.res.getChildForRequest(request)
val = res.render(request)
if val != NOT_DONE_YET:
request.write(val)
request.finish()
except:
io = StringIO()
traceback.print_exc(file=io)
request.write(html.PRE(io.getvalue()))
request.finish()
return widgets.FORGET_IT
def process(self, write, request, submit, **kw):
"""Override me: I process a form.
I will only be called when the correct form input data to process this
form has been received.
I take a variable number of arguments, beginning with 'write',
'request', and 'submit'. 'write' is a callable object that will append
a string to the response, 'request' is a twisted.web.request.Request
instance, and 'submit' is the name of the submit action taken.
The remainder of my arguments must be correctly named. They will each be named after one of the
"""
write("<pre>Submit: %s <br /> %s</pre>" % (submit, html.PRE(pprint.PrettyPrinter().pformat(kw))))
def possiblyDeferWidget(widget, request):
# web in my head get it out get it out
try:
disp = widget.display(request)
# if this widget wants to defer anything -- well, I guess we've got to
# defer it.
for elem in disp:
if isinstance(elem, defer.Deferred):
req = _RequestDeferral()
RenderSession(disp, req)
return req.deferred
return string.join(disp, '')
except:
io = StringIO()
traceback.print_exc(file=io)
return html.PRE(io.getvalue())
def keepRendering(self):
while self.pauseList:
pl = self.pauseList
self.pauseList = []
for deferred in pl:
deferred.unpause()
return
if self.needsHeaders:
# short circuit actual rendering process until we're sure no
# more deferreds need to set headers...
return
assert self.lst is not None, "This shouldn't happen."
while 1:
item = self.lst[0]
if self.beforeBody and FORGET_IT in self.lst:
# If I haven't moved yet, and the widget wants to take
# over the page, let it do so!
self.forgotten = 1
return
if isinstance(item, types.StringType):
self.beforeBody = 0
self.request.write(item)
elif type(item) is types.TupleType and len(item) > 0:
if isinstance(item[0], self.Sentinel):
return
elif isinstance(item, failure.Failure):
self.request.write(webutil.formatFailure(item))
else:
self.beforeBody = 0
unknown = html.PRE(repr(item))
self.request.write("RENDERING UNKNOWN: %s" % unknown)
del self.lst[0]
if len(self.lst) == 0:
self.lst = None
self.request.finish()
return
def keepRendering(self):
if self.needsHeaders:
# short circuit actual rendering process until we're sure no more
# deferreds need to set headers...
return
assert self.lst is not None, "This shouldn't happen."
while 1:
item = self.lst[self.position]
if self.position == 0 and item == FORGET_IT:
# If I haven't moved yet, and the widget wants to take over the page, let it do so!
return
if isinstance(item, types.StringType):
self.request.write(item)
elif isinstance(item, defer.Deferred):
return
else:
self.request.write("RENDERING UNKNOWN: %s" %
html.PRE(repr(item)))
self.position = self.position + 1
if self.position == len(self.lst):
self.lst = None
self.request.finish()
return
def formatTraceback(self, tb):
return [html.PRE(tb)]
self.filename = filename
self.registry = registry
def render(self, request):
"""Render me to a web client.
Load my file, execute it in a special namespace (with 'request' and
'__file__' global vars) and finish the request. Output to the web-page
will NOT be handled with print - standard output goes to the log - but
with request.write.
"""
request.setHeader("x-powered-by", "Twisted/%s" % copyright.version)
namespace = {
'request': request,
'__file__': self.filename,
'registry': self.registry
}
try:
execfile(self.filename, namespace, namespace)
except IOError, e:
if e.errno == 2: #file not found
request.setResponseCode(http.NOT_FOUND)
request.write(
error.NoResource("File not found.").render(request))
except:
io = StringIO.StringIO()
traceback.print_exc(file=io)
request.write(html.PRE(io.getvalue()))
request.finish()
return server.NOT_DONE_YET
def formatFailure(myFailure):
exceptionHTML = """
<p class="error">%s: %s</p>
"""
frameHTML = """
<div class="location">%s, line %s in <span class="function">%s</span></div>
"""
snippetLineHTML = """
<div class="snippetLine"><span class="lineno">%s</span><span class="code">%s</span></div>
"""
snippetHighlightLineHTML = """
<div class="snippetHighlightLine"><span class="lineno">%s</span><span class="code">%s</span></div>
"""
variableHTML = """
<tr class="varRow"><td class="varName">%s</td><td class="varValue">%s</td></tr>
"""
if not isinstance(myFailure, failure.Failure):
return html.PRE(str(myFailure))
io = StringIO()
w = io.write
w(stylesheet)
w('<a href="#tbend">')
w(exceptionHTML %
(html.escape(str(myFailure.type)), html.escape(str(myFailure.value))))
w('</a>')
w('<div class="stackTrace">')
first = 1
for method, filename, lineno, localVars, globalVars in myFailure.frames:
if filename == '<string>':
continue
if first:
w('<div class="firstFrame">')
first = 0
else:
w('<div class="frame">')
w(frameHTML % (filename, lineno, method))
w('<div class="snippet">')
textSnippet = ''
for snipLineNo in range(lineno - 2, lineno + 2):
snipLine = linecache.getline(filename, snipLineNo)
textSnippet += snipLine
snipLine = htmlIndent(snipLine)
if snipLineNo == lineno:
w(snippetHighlightLineHTML % (snipLineNo, snipLine))
else:
w(snippetLineHTML % (snipLineNo, snipLine))
w('</div>')
# Instance variables
for name, var in localVars:
if name == 'self' and hasattr(var, '__dict__'):
usedVars = [
(key, value) for (key, value) in var.__dict__.items()
if re.search(r'\W' + 'self.' + key + r'\W', textSnippet)
]
if usedVars:
w('<div class="variables"><b>Self</b>')
w('<table class="variables">')
for key, value in usedVars:
w(variableHTML % (key, htmlrepr(value)))
w('</table></div>')
break
# Local and global vars
for nm, varList in ('Locals', localVars), ('Globals', globalVars):
usedVars = [(name, var) for (name, var) in varList
if re.search(r'\W' + name + r'\W', textSnippet)]
if usedVars:
w('<div class="variables"><b>%s</b><table class="variables">' %
nm)
for name, var in usedVars:
w(variableHTML % (name, htmlrepr(var)))
w('</table></div>')
w('</div>') # frame
w('</div>') # stacktrace
w('<a name="tbend"> </a>')
w(exceptionHTML %
(html.escape(str(myFailure.type)), html.escape(str(myFailure.value))))
return io.getvalue()
def formatTraceback(self, traceback):
return [html.PRE(traceback)]
