%s
' % self.setting('UserErrorMessage'), '', '\n')) def privateErrorPage(self): """Return a private error page. Returns an HTML page intended for the developer with useful information such as the traceback. Most of the contents are generated in `htmlDebugInfo`. """ html = [docType(), '', '', '%s
' % self.setting('UserErrorMessage')] html.append(self.htmlDebugInfo()) html.extend(['', '\n']) return '\n'.join(html) def htmlDebugInfo(self): """Return the debug info. Return HTML-formatted debugging information about the current exception. Calls `writeHTML`, which uses ``self.write(...)`` to add content. """ self._html = [] self.writeHTML() html = ''.join(self._html) self._html = None return html def writeHTML(self): """Write the traceback. Writes all the parts of the traceback, invoking: * `writeTraceback` * `writeMiscInfo` * `writeTransaction` * `writeEnvironment` * `writeIds` * `writeFancyTraceback` """ self.writeTraceback() self.writeMiscInfo() self.writeTransaction() self.writeEnvironment() self.writeIds() self.writeFancyTraceback() ## Write Methods ## def write(self, s): """Output `s` to the body.""" self._html.append(str(s)) def writeln(self, s): """Output `s` plus a newline.""" self._html.append(str(s)) self._html.append('\n') def writeTitle(self, s): """Output the sub-heading to define a section.""" self.writeln(htTitle(s)) def writeDict(self, d, heading=None, encoded=None): """Output a table-formated dictionary.""" self.writeln(htmlForDict(d, addSpace=self._addSpace, filterValueCallBack=self.filterDictValue, maxValueLength=self._maxValueLength, topHeading=heading, isEncoded=encoded)) def writeAttrs(self, obj, attrNames): """Output object attributes. Writes the attributes of the object as given by attrNames. Tries ``obj._name` first, followed by ``obj.name()``. Is resilient regarding exceptions so as not to spoil the exception report. """ attrs = {} for name in attrNames: value = getattr(obj, '_' + name, Singleton) # go for data attribute try: if value is Singleton: value = getattr(obj, name, Singleton) # go for method if value is Singleton: value = '(could not find attribute or method)' else: try: if callable(value): value = value() value = self.repr(value) except Exception, e: value = ('(exception during method call:' ' %s: %s)' % (e.__class__.__name__, e)) else: value = self.repr(value) except Exception, e: value = ('(exception during value processing:' ' %s: %s)' % (e.__class__.__name__, e)) attrs[name] = value self.writeDict(attrs, ('Attribute', 'Value'), True) ## Traceback sections ## def writeTraceback(self): """Output the traceback. Writes the traceback, with most of the work done by `WebUtils.HTMLForException.HTMLForException`. """ self.writeTitle('Traceback') self.write('%s
' % self.servletPathname()) self.write(HTMLForException(self._exc, self._formatOptions)) def writeMiscInfo(self): """Output misc info. Write a couple little pieces of information about the environment. """ self.writeTitle('MiscInfo') info = { 'time': asclocaltime(self._time), 'filename': self.servletPathname(), 'os.getcwd()': os.getcwd(), 'sys.path': sys.path, 'sys.version': sys.version, } self.writeDict(info) def writeTransaction(self): """Output transaction. Lets the transaction talk about itself, using `Transaction.writeExceptionReport`. """ if self._tra: self._tra.writeExceptionReport(self) else: self.writeTitle("No current Transaction.") def writeEnvironment(self): """Output environment. Writes the environment this is being run in. This is *not* the environment that was passed in with the request (holding the CGI information) -- it's just the information from the environment that the AppServer is being executed in. """ self.writeTitle('Environment') self.writeDict(os.environ) def writeIds(self): """Output OS identification. Prints some values from the OS (like processor ID). """ self.writeTitle('OS Ids') self.writeDict(osIdDict(), ('Name', 'Value')) def writeFancyTraceback(self): """Output a fancy traceback, using CGITraceback.""" if self.setting('IncludeFancyTraceback'): self.writeTitle('Fancy Traceback') try: from WebUtils.ExpansiveHTMLForException import ( ExpansiveHTMLForException) self.write(ExpansiveHTMLForException( context=self.setting('FancyTracebackContext'))) except Exception: self.write('Unable to generate a fancy traceback' ' (uncaught exception)!
') try: self.write(HTMLForException(sys.exc_info())) except Exception: self.write('Unable to even generate a normal traceback' ' of the exception in fancy traceback!
') def saveErrorPage(self, html): """Save the error page. Saves the given HTML error page for later viewing by the developer, and returns the filename used. """ filename = os.path.join(self._app._errorMessagesDir, self.errorPageFilename()) try: f = open(filename, 'w') try: f.write(html) finally: f.close() except IOError: sys.stderr.write('[%s] [error] WebKit: Cannot save error page (%s)\n' % (asclocaltime(self._time), filename)) else: return filename def errorPageFilename(self): """Create filename for error page. Construct a filename for an HTML error page, not including the ``ErrorMessagesDir`` setting (which `saveError` adds on). """ # Note: Using the timestamp and a random number is a poor technique # for filename uniqueness, but it is fast and good enough in practice. return 'Error-%s-%s-%06d.html' % (self.basicServletName(), '-'.join(map(lambda x: '%02d' % x, localtime(self._time)[:6])), randint(0, 999999)) def logExceptionToDisk(self, errorMsgFilename=None): """Log the exception to disk. Writes a tuple containing (date-time, filename, pathname, exception-name, exception-data,error report filename) to the errors file (typically 'Errors.csv') in CSV format. Invoked by `handleException`. """ if not self.setting('LogErrors'): return err, msg = self._exc[:2] if isinstance(err, basestring): # string exception err, msg = '', str(msg or err) else: err, msg = err.__name__, str(msg) logline = (asclocaltime(self._time), self.basicServletName(), self.servletPathname(), err, msg, errorMsgFilename or '') def fixElement(element): element = str(element) if ',' in element or '"' in element: element = element.replace('"', '""') element = '"%s"' % element return element logline = map(fixElement, logline) filename = self._app.serverSidePath(self.setting('ErrorLogFilename')) if os.path.exists(filename): f = open(filename, 'a') else: f = open(filename, 'w') f.write('time,filename,pathname,exception name,' 'exception data,error report filename\n') f.write(','.join(logline) + '\n') f.close() def emailException(self, htmlErrMsg): """Email the exception. Send the exception via mail, either as an attachment, or as the body of the mail. """ message = Message() # Construct the message headers headers = self.setting('ErrorEmailHeaders').copy() headers['Date'] = formatdate() headers['Mime-Version'] = '1.0' headers['Subject'] = headers.get('Subject', '[WebKit Error]') + ' %s: %s' % sys.exc_info()[:2] for h, v in headers.items(): if isinstance(v, (list, tuple)): v = ','.join(v) message.add_header(h, v) # Construct the message body if self.setting('EmailErrorReportAsAttachment'): # start off with a text/plain part text = ('WebKit caught an exception while processing' ' a request for "%s" at %s (timestamp: %s).' ' The plain text traceback from Python is printed below and' ' the full HTML error report from WebKit is attached.\n\n' % (self.servletPathname(), asclocaltime(self._time), self._time)) message.set_type('multipart/mixed') part = Message() part.set_type('text/plain') body = StringIO() body.write(text) traceback.print_exc(file=body) part.set_payload(body.getvalue()) body.close() message.attach(part) part = Message() # now add htmlErrMsg part.add_header('Content-Transfer-Encoding', '7bit') part.add_header('Content-Description', 'HTML version of WebKit error message') part.add_header('Content-Disposition', 'attachment', filename='WebKitErrorMsg.html') part.set_type('text/html') part.set_payload(htmlErrMsg) message.attach(part) else: message.set_type('text/html') message.set_payload(htmlErrMsg, 'us-ascii') # Send the message server = self.setting('ErrorEmailServer') # This setting can be: server, server:port, server:port:user:password # or server:port:user:password:popserver:popport for "smtp after pop". parts = server.split(':', 5) server = port = user = passwd = None popserver = popssl = popport = None try: server = parts[0] try: port = int(parts[1]) except ValueError: pass user = parts[2] passwd = parts[3] popserver = parts[4] try: popport = int(parts[5]) except ValueError: popport = None if parts[6].lower() == 'ssl': popssl = True except IndexError: pass if user and passwd and popserver: # SMTP after POP if popssl is None and popport == 995: popssl = True popssl = popssl and poplib.POP3_SSL or poplib.POP3 if popport: popserver = popssl(popserver, popport) else: popserver = popssl(popserver) popserver.set_debuglevel(0) popserver.user(user) popserver.pass_(passwd) try: popserver.quit() except Exception: pass if port: server = smtplib.SMTP(server, port) else: server = smtplib.SMTP(server) try: server.set_debuglevel(0) if user and passwd and not popserver: # SMTP-AUTH server.ehlo() if server.has_extn('starttls'): server.starttls() server.ehlo() server.login(user, passwd) body = message.as_string() server.sendmail(headers['From'], headers['To'], body) finally: try: server.quit() except Exception: pass ## Filtering ## def filterDictValue(self, value, key, dict): """Filter dictionary values. Filters keys from a dict. Currently ignores the dictionary, and just filters based on the key. """ return self.filterValue(value, key) def filterValue(self, value, key): """Filter values. This is the core filter method that is used in all filtering. By default, it simply returns self._hiddenString if the key is in self._hideValuesForField (case insensitive). Subclasses could override for more elaborate filtering techniques. """ try: key = key.lower() except Exception: pass if key in self._hideValuesForFields: return self._hiddenString else: return value ## Utility ## def repr(self, value): """Get HTML encoded representation. Returns the repr() of value already HTML encoded. As a special case, dictionaries are nicely formatted in table. This is a utility method for `writeAttrs`. """ if isinstance(value, dict): return htmlForDict(value, addSpace=self._addSpace, filterValueCallBack=self.filterDictValue, maxValueLength=self._maxValueLength) else: rep = repr(value) if self._maxValueLength and len(rep) > self._maxValueLength: rep = rep[:self._maxValueLength] + '...' return htmlEncode(rep) ## Misc functions ## def docType(): """Return the document type for the page.""" return ('') def htStyle(): """Return the page style.""" return ('''''') def htTitle(name): """Format a `name` as a section title.""" return ('