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)]