def manageError(self, error):
'''Manages an error.'''
tb = sys.exc_info()
from zExceptions.ExceptionFormatter import format_exception
htmlMessage = format_exception(tb[0], tb[1], tb[2], as_html=1)
textMessage = format_exception(tb[0], tb[1], tb[2], as_html=0)
self.log(''.join(textMessage).strip(), type='error')
return '<table class="main" align="center" cellpadding="0"><tr>' \
'<td style="padding: 1em 1em 1em 1em">An error occurred. %s' \
'</td></tr></table>' % '\n'.join(htmlMessage)
def manageError(self, error):
'''Manages an error.'''
tb = sys.exc_info()
from zExceptions.ExceptionFormatter import format_exception
htmlMessage = format_exception(tb[0], tb[1], tb[2], as_html=1)
textMessage = format_exception(tb[0], tb[1], tb[2], as_html=0)
self.log(''.join(textMessage).strip(), type='error')
return '<table class="main" align="center" cellpadding="0"><tr>' \
'<td style="padding: 1em 1em 1em 1em">An error occurred. %s' \
'</td></tr></table>' % '\n'.join(htmlMessage)
def __init__(self, event):
info = event.info
tb_text = None
tb_html = None
strtype = str(getattr(info[0], '__name__', info[0]))
if not isinstance(info[2], basestring):
tb_text = ''.join(
format_exception(*info, **{'as_html': 0}))
tb_html = ''.join(
format_exception(*info, **{'as_html': 1}))
else:
tb_text = info[2]
request = getattr(self, 'REQUEST', None)
url = None
username = None
userid = None
req_html = None
try:
strv = str(info[1])
except:
strv = '<unprintable %s object>' % type(info[1]).__name__
if request:
url = request.get('URL', '?')
usr = getSecurityManager().getUser()
username = usr.getUserName()
userid = usr.getId()
try:
req_html = str(request)
except:
pass
if strtype == 'NotFound':
strv = url
next = request['TraversalRequestNameStack']
if next:
next = list(next)
next.reverse()
strv = '%s [ /%s ]' % (strv, '/'.join(next))
self.context = event.context
self.level = 'ERROR'
self.subject = ': '.join([strtype, strv])
self.message = tb_text
self.data = {
'type': strtype,
'value': strv,
'tb_text': tb_text,
'tb_html': tb_html,
'username': username,
'userid': userid,
'url': url,
'req_html': req_html,
}
def __call__(self):
exception = self.context
self.context = self.__parent__
request = self.request
error_type = exception.__class__.__name__
error_tb = ''.join(format_exception(*sys.exc_info(), as_html=True))
# Indicate exception as JSON
if "text/html" not in request.getHeader('Accept', ''):
request.response.setHeader("Content-Type", "application/json")
return json.dumps({
'error_type': error_type,
})
# Use a simplified template if main_template is not available
try:
self.context.unrestrictedTraverse('main_template')
except:
template = self.basic_template
else:
template = self.index
# Render page with user-facing error notice
request.set('disable_border', True)
request.set('disable_plone.leftcolumn', True)
request.set('disable_plone.rightcolumn', True)
return template(
error_type=error_type,
error_tb=error_tb,
)
def __call__(self):
exception = self.context
self.context = self.__parent__
request = self.request
error_type = exception.__class__.__name__
exc_type, value, traceback = sys.exc_info()
error_tb = ''.join(
format_exception(exc_type, value, traceback, as_html=False))
request.response.setStatus(exc_type)
# Indicate exception as JSON
if "text/html" not in request.getHeader('Accept', ''):
request.response.setHeader("Content-Type", "application/json")
return json.dumps({
'error_type': error_type,
})
# Render page with user-facing error notice
request.set('disable_border', True)
request.set('disable_plone.leftcolumn', True)
request.set('disable_plone.rightcolumn', True)
try:
return self.index(
error_type=error_type,
error_tb=error_tb)
except:
return self.basic_template(
error_type=error_type,
error_tb=error_tb)
def render(self, view=False, preview=False):
if self.source is None:
raise error.SourceMissingError('unknow')
if preview and not self.source.is_previewable():
raise error.SourcePreviewError(self)
values = {}
template = None
if self.parameterFields:
if not self.ignoreRequest:
values, errors = self.extractData(self.parameterFields)
if errors:
raise error.ParametersError(errors)
elif not self.ignoreContent and self.getContent() is not None :
template = self.getContent().get_source_template()
manager = self.getContentData()
for field in self.parameterFields:
try:
value = manager.get(field.identifier)
except KeyError:
value = field.getDefaultValue(self)
values[field.identifier] = value
else:
raise error.ParametersError()
try:
html = self.source.to_html(self.context, self.request, **values)
except:
info = u''.join(format_exception(*sys.exc_info()))
getUtility(ISourceErrors).report(info)
raise error.SourceRenderingError(self, info)
if not preview and template:
html = template.replace('<!-- source output -->', html)
return html
def render(self, view=False, preview=False):
if self.source is None:
raise error.SourceMissingError('unknow')
if preview and not self.source.is_previewable():
raise error.SourcePreviewError(self)
values = {}
template = None
if self.parameterFields:
if not self.ignoreRequest:
values, errors = self.extractData(self.parameterFields)
if errors:
raise error.ParametersError(errors)
elif not self.ignoreContent and self.getContent() is not None:
template = self.getContent().get_source_template()
manager = self.getContentData()
for field in self.parameterFields:
try:
value = manager.get(field.identifier)
except KeyError:
value = field.getDefaultValue(self)
values[field.identifier] = value
else:
raise error.ParametersError()
try:
html = self.source.to_html(self.context, self.request, **values)
except:
info = u''.join(format_exception(*sys.exc_info()))
getUtility(ISourceErrors).report(info)
raise error.SourceRenderingError(self, info)
if not preview and template:
html = template.replace('<!-- source output -->', html)
return html
def __call__(self):
self.exception = aq_inner(self.context)
self.context = aq_parent(self)
log.exception("Error at %r", self.context)
error_type = self.exception.__class__.__name__
exc_type, value, traceback = sys.exc_info()
error_tb = "".join(
format_exception(exc_type, value, traceback, as_html=False))
try:
return self.index()
except Exception:
return self.basic_template(error_type=error_type,
error_tb=error_tb)
def testCheckZuitePageTemplatesValidHTML(self):
# Check the zuite page templates can be rendered, because selenium test
# runner does not report error in case there are errors in the page
# template.
tests_tool = self.portal.portal_tests
for page_template_path, page_template in tests_tool.ZopeFind(
tests_tool, obj_metatypes=['Page Template'], search_sub=1):
try:
page_template.pt_render()
except (KeyboardInterrupt, SystemExit):
raise
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
self.fail(
'Rendering of %s failed with error:\n%s' %
(page_template_path, ''.join(
format_exception(
exc_type, exc_value, exc_traceback,
as_html=False))))
def testCheckZuitePageTemplatesValidHTML(self):
# Check the zuite page templates can be rendered, because selenium test
# runner does not report error in case there are errors in the page
# template.
tests_tool = self.portal.portal_tests
for page_template_path, page_template in tests_tool.ZopeFind(
tests_tool, obj_metatypes=['Page Template'], search_sub=1):
try:
page_template.pt_render()
except (KeyboardInterrupt, SystemExit):
raise
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
self.fail('Rendering of %s failed with error:\n%s' % (
page_template_path,
''.join(format_exception(
exc_type,
exc_value,
exc_traceback,
as_html=False))))
def fail(self, comment, exception=None):
"""Put the life cycle instance object into `failed` state."""
if self.state in ['ended', 'failed']:
# Ignore failure requests when we are failed already, or ended.
return
self.__parent__.aq_inner.onFailure()
if DEBUG_FAILURE:
raise
self.state = 'failed'
if exception is not None:
# XXX This should be changed to derive the exception information
# from the exception instance, as soon as python has this feature.
exc_info = sys.exc_info()
comment = comment + "<br/><b>Exception details:</b><br/>" + \
''.join(format_exception(*exc_info, **{'as_html':1}))
self.recordEvent("failed", "failed",
"A failure occured:<br/>" + comment)
zope.event.notify(LifeCycleEvent(self.__parent__))
def exception(self, content):
self.exceptions += 1
output = StringIO()
self._common_blah(output, content)
if len(content.errors) > 0:
output.write("<h4>Validation Errors</h4>")
output.write("<table>")
for key, value in content.errors.iteritems():
output.write("<tr>")
output.write("<td>%s</td><td>%s</td>" % (key, value))
output.write("</tr>")
output.write("</table>")
#output.write("<h4>Error Info</h4>")
#output.write("<table>")
#for key in ('username', 'url', 'userid', 'value', 'time', 'type', 'id'):
# output.write("<tr><td>%s</td><td>%s</td></tr>" % (key, site_error[key]))
#output.write("</table>")
output.write("<h4>Traceback</h4>")
output.write("<pre>")
#srsly? there has to be a better way :(
traceback = content.traceback
if not traceback:
traceback = sys.exc_info()
tb = ''.join(format_exception(*traceback, **{"as_html":0}))
idx = tb.find("<!DOCTYPE")
if idx >= 0:
tb = tb[:idx].strip()
output.write(cgi.escape(tb))
output.write("</pre>")
tb_info = "".join(self.traceback_info_re.findall(tb)[-1:])
exception = "".join(tb.strip().split("\n")[-1:])
self.exception_log.setdefault((exception, tb_info), []).append(output)
def testFunctionalTestRunner(self):
# Check the zuite page templates can be rendered, because selenium test
# runner does not report error in case there are errors in the page
# template.
tests_tool = self.portal.portal_tests
if self.remote_code_url_list:
# This does not really run tests. It initializes a zuite
# and redirect to a url to would actually run them.
tests_tool.Zuite_runSeleniumTest(self.remote_code_url_list,
self.run_only)
self.commit()
for page_template_path, page_template in tests_tool.ZopeFind(
tests_tool[self.run_only] if self.run_only else tests_tool,
obj_metatypes=('Page Template', ),
search_sub=1):
try:
page_template.pt_render()
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
self.fail(
'Rendering of %s failed with error:\n%s' %
(page_template_path, ''.join(
format_exception(
exc_type, exc_value, exc_traceback,
as_html=False))))
# abort to get rid of the mysql participation in this transaction
self.portal._p_jar.sync()
debug = self.foreground or os.environ.get("erp5_debug_mode")
error = None
try:
iframe = self.runner.test(debug=debug)
except TimeoutError, e:
error = repr(e)
self._verboseErrorLog(20)
def testFunctionalTestRunner(self):
# Check the zuite page templates can be rendered, because selenium test
# runner does not report error in case there are errors in the page
# template.
tests_tool = self.portal.portal_tests
if self.remote_code_url_list:
# This does not really run tests. It initializes a zuite
# and redirect to a url to would actually run them.
tests_tool.Zuite_runSeleniumTest(self.remote_code_url_list, self.run_only)
self.commit()
for page_template_path, page_template in tests_tool.ZopeFind(
tests_tool[self.run_only] if self.run_only else tests_tool,
obj_metatypes=('Page Template',), search_sub=1):
try:
page_template.pt_render()
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
self.fail('Rendering of %s failed with error:\n%s' % (
page_template_path,
''.join(format_exception(
exc_type,
exc_value,
exc_traceback,
as_html=False))))
# abort to get rid of the mysql participation in this transaction
self.portal._p_jar.sync()
debug = self.foreground or os.environ.get("erp5_debug_mode")
error = None
try:
self.runner.test(debug=debug)
except TimeoutError, e:
error = repr(e)
self._verboseErrorLog(20)
def raising(self, info):
"""Log an exception.
Called by SimpleItem's exception handler.
Returns the url to view the error log entry
"""
try:
now = time.time()
try:
tb_text = None
tb_html = None
strtype = str(getattr(info[0], '__name__', info[0]))
if strtype in self._ignored_exceptions:
return
if not isinstance(info[2], basestring):
tb_text = ''.join(format_exception(*info, **{'as_html':
0}))
tb_html = ''.join(format_exception(*info, **{'as_html':
1}))
else:
tb_text = info[2]
request = getattr(self, 'REQUEST', None)
url = None
username = None
userid = None
req_html = None
try:
strv = str(info[1])
except:
strv = '<unprintable %s object>' % type(info[1]).__name__
if request:
url = request.get('URL', '?')
usr = getSecurityManager().getUser()
username = usr.getUserName()
userid = usr.getId()
try:
req_html = str(request)
except:
pass
if strtype == 'NotFound':
strv = url
next = request['TraversalRequestNameStack']
if next:
next = list(next)
next.reverse()
strv = '%s [ /%s ]' % (strv, '/'.join(next))
log = self._getLog()
entry_id = str(now) + str(random()) # Low chance of collision
log.append({
'type': strtype,
'value': strv,
'time': now,
'id': entry_id,
'tb_text': tb_text,
'tb_html': tb_html,
'username': username,
'userid': userid,
'url': url,
'req_html': req_html,
})
cleanup_lock.acquire()
try:
if len(log) >= self.keep_entries:
del log[:-self.keep_entries]
finally:
cleanup_lock.release()
except:
LOG.error('Error while logging', exc_info=sys.exc_info())
else:
if self.copy_to_zlog:
self._do_copy_to_zlog(now, strtype, str(url), tb_text)
return '%s/showEntry?id=%s' % (self.absolute_url(), entry_id)
finally:
info = None
def raise_standardErrorMessage(self, c, r, t, v, tb, error_log_url):
from zExceptions.ExceptionFormatter import format_exception
fmt = format_exception(t, v, tb, as_html=0)
self.messages.append(''.join([error_log_url] + fmt))
def pretty_tb(t, v, tb, as_html=1):
tb = format_exception(t, v, tb, as_html=as_html)
tb = '\n'.join(tb)
return tb
def pretty_exc(self, exc, *args, **kw):
t, e, tb = exc
try:
return ''.join(format_exception(t, e, tb, format_src=1))
except:
return ''.join(format_exception(t, e, tb))
def pretty_tb(t, v, tb, as_html=1):
tb = format_exception(t, v, tb, as_html=as_html)
tb = '\n'.join(tb)
return tb
def _traceback(self, t, v, tb, as_html=1):
return ''.join(format_exception(t, v, tb, as_html=as_html))
def raising(self, info):
"""Log an exception.
Called by SimpleItem's exception handler.
Returns the url to view the error log entry
"""
now = time.time()
try:
tb_text = None
tb_html = None
strtype = str(getattr(info[0], '__name__', info[0]))
if strtype in self._ignored_exceptions:
return
if not isinstance(info[2], bstr):
tb_text = ''.join(
format_exception(*info, **{'as_html': 0}))
tb_html = ''.join(
format_exception(*info, **{'as_html': 1}))
else:
tb_text = info[2]
request = getattr(self, 'REQUEST', None)
url = None
username = None
userid = None
req_html = None
try:
strv = str(info[1])
except Exception:
strv = '<unprintable %s object>' % type(info[1]).__name__
if request:
url = request.get('URL', '?')
usr = getSecurityManager().getUser()
username = usr.getUserName()
userid = usr.getId()
try:
req_html = str(request)
except Exception:
pass
if strtype == 'NotFound':
strv = url
next = request['TraversalRequestNameStack']
if next:
next = list(next)
next.reverse()
strv = '%s [ /%s ]' % (strv, '/'.join(next))
log = self._getLog()
entry_id = str(now) + str(random()) # Low chance of collision
log.append({
'type': strtype,
'value': strv,
'time': now,
'id': entry_id,
'tb_text': tb_text,
'tb_html': tb_html,
'username': username,
'userid': userid,
'url': url,
'req_html': req_html})
cleanup_lock.acquire()
try:
if len(log) >= self.keep_entries:
del log[:-self.keep_entries]
finally:
cleanup_lock.release()
except Exception:
LOG.error('Error while logging', exc_info=sys.exc_info())
else:
notify(ErrorRaisedEvent(log[-1]))
if self.copy_to_zlog:
self._do_copy_to_zlog(now, strtype, entry_id,
str(url), tb_text)
return '%s/showEntry?id=%s' % (self.absolute_url(), entry_id)
def tb(as_html=0):
t, v, b = sys.exc_info()
try:
return ''.join(format_exception(t, v, b, as_html=as_html))
finally:
del b
def _traceback(self, t, v, tb, as_html=1):
tb = format_exception(t, v, tb, as_html=as_html)
return '\n'.join(tb)
def tb(as_html=0):
t, v, b = sys.exc_info()
try:
return ''.join(format_exception(t, v, b, as_html=as_html))
finally:
del b
def raise_standardErrorMessage(self, c, r, t, v, tb, error_log_url):
from zExceptions.ExceptionFormatter import format_exception
fmt = format_exception(t, v, tb, as_html=0)
self.messages.append(''.join([error_log_url] + fmt))
def _traceback(self, t, v, tb, as_html=1):
tb = format_exception(t, v, tb, as_html=as_html)
return '\n'.join(tb)
def raising(self, info):
"""Log an exception.
Called by SimpleItem's exception handler.
Returns the url to view the error log entry
"""
try:
now = time.time()
try:
tb_text = None
tb_html = None
strtype = str(getattr(info[0], '__name__', info[0]))
if strtype in self._ignored_exceptions:
return
if not isinstance(info[2], StringType) and not isinstance(
info[2], UnicodeType):
tb_text = ''.join(
format_exception(*info, **{'as_html': 0}))
tb_html = ''.join(
format_exception(*info, **{'as_html': 1}))
else:
tb_text = info[2]
request = getattr(self, 'REQUEST', None)
url = None
username = None
userid = None
req_html = None
if request:
url = request.get('URL', '?')
usr = getSecurityManager().getUser()
username = usr.getUserName()
userid = usr.getId()
try:
req_html = str(request)
except:
pass
try:
strv = str(info[1])
except:
strv = '<unprintable %s object>' % str(type(info[1]).__name__)
log = self._getLog()
entry_id = str(now) + str(random()) # Low chance of collision
log.append({
'type': strtype,
'value': strv,
'time': now,
'id': entry_id,
'tb_text': tb_text,
'tb_html': tb_html,
'username': username,
'userid': userid,
'url': url,
'req_html': req_html,
})
cleanup_lock.acquire()
try:
if len(log) >= self.keep_entries:
del log[:-self.keep_entries]
finally:
cleanup_lock.release()
except:
LOG('SiteError', ERROR, 'Error while logging',
error=sys.exc_info())
else:
if self.copy_to_zlog:
self._do_copy_to_zlog(now,strtype,str(url),info)
return '%s/showEntry?id=%s' % (self.absolute_url(), entry_id)
finally:
info = None
