def do_GET(self):
"""Handle all HTTP GET requests"""
try:
self.parsed_uri = urlparse(self.path)
self.query = {}
for (key, val) in cgi.parse_qsl(self.parsed_uri[4]):
# print "DEBUG: checking input arg %s: '%s'" % (key, val)
validate_helper = self.validators.get(key, invalid_argument)
# Let validation errors pass to general exception handler below
validate_helper(val)
self.query[key] = val
self.setUser()
# print "DEBUG: checking path '%s'" % self.parsed_uri[2]
valid_path(self.parsed_uri[2])
path = self.parsed_uri[2]
# Strip server_base before testing location
path = path.replace("%s/" % self.server.server_base, '', 1)
if path == '/':
self.showMainPage()
elif path.startswith('/ping'):
self.showPingPage()
elif path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/login':
self.showLoginPage('/%s/' % self.server.server_base,
'/%s/' % self.server.server_base)
elif path == '/loginsubmit':
self.doLogin()
elif path.startswith('/id/'):
self.showIdPage(path)
elif path.startswith('/yadis/'):
self.showYadis(path[7:])
elif path == '/serveryadis':
self.showServerYadis()
else:
self.send_response(404)
self.end_headers()
except (KeyboardInterrupt, SystemExit):
raise
except:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
print "ERROR: %s" % cgitb.html(sys.exc_info(), context=10)
def catch(self, environ, start_response):
'''Exception catcher.'''
# Log exception
if self.log: self.logger.exception(self.message)
# Debug
if self.debug: pdb.pm()
# Write HTML-formatted exception tracebacks to a file
if self.htmlfile is not None:
open(self.htmlfile, 'wb').write(html(sys.exc_info()))
# Send HTML-formatted exception tracebacks to the browser
if self.tohtml:
start_response(HTTPMSG, [('Content-type', 'text/html')])
return [html(sys.exc_info())]
# Return error handler
return self._errapp(environ, start_response)
def catch(self, environ, start_response):
'''Exception catcher.'''
# Log exception
if self.log: self.logger.exception(self.message)
# Debug
if self.debug: pdb.pm()
# Write HTML-formatted exception tracebacks to a file
if self.htmlfile is not None:
open(self.htmlfile, 'wb').write(html(sys.exc_info()))
# Send HTML-formatted exception tracebacks to the browser
if self.tohtml:
start_response(HTTPMSG, [('Content-type', 'text/html')])
return [html(sys.exc_info())]
# Return error handler
return self._errapp(environ, start_response)
def do_GET(self):
try:
self.parsed_uri = urlparse(self.path)
self.query = {}
for k, v in cgi.parse_qsl(self.parsed_uri[4]):
self.query[k] = v
self.setUser()
path = self.parsed_uri[2].lower()
if path == '/':
self.showMainPage()
elif path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/login':
self.showLoginPage('/', '/')
elif path == '/loginsubmit':
self.doLogin()
else:
self.showIdPage(path)
except (KeyboardInterrupt, SystemExit):
raise
except:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
def __call_service(self, query):
"""Execute service method implemented by child class.
When either a GET or POST request is received, this method is
called with a string representing the query. Request and response
objects are created for the child's service method, and an answer
is sent back to the client with errors automatically being caught."""
request = _HttpServletRequest(query)
response = _HttpServletResponse()
try:
self.service(request, response)
except Exception:
if self.__debug:
self.send_response(500)
self.send_header('Content-Type', 'text/html')
self.send_header('Connection', 'close')
self.end_headers()
klass, value, trace = sys.exc_info()
print 'trace:',trace
# The next function call may raise an exception.
html = cgitb.html((klass, value, trace.tb_next))
self.wfile.write(html.encode())
else:
self.send_error(500)
else:
response_value = response._value
self.send_response(200)
self.send_header('Content-Type', response._type)
self.send_header('Content-Length', str(len(response_value)))
self.end_headers()
self.wfile.write(response_value)
def do_GET(self):
try:
self.parsed_uri = urlparse(self.path)
self.query = {}
for k, v in parse_qsl(self.parsed_uri[4]):
self.query[k] = v
self.setUser()
path = self.parsed_uri[2].lower()
if path == '/':
self.showMainPage()
elif path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/login':
self.showLoginPage('/', '/')
elif path == '/loginsubmit':
self.doLogin()
elif path.startswith('/id/'):
self.showIdPage(path)
elif path.startswith('/yadis/'):
self.showYadis(path[7:])
elif path == '/serveryadis':
self.showServerYadis()
else:
self.send_response(404)
self.end_headers()
except Exception:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
def generateHtml(self, einfo=None):
index = open(self.htmlFile, "w")
index.write(
"""<html>
<body>
"""
)
for i, (description, images) in enumerate(self.steps):
stepNumber = i + 1
index.write("<h2>%s. %s</h2>\n" % (stepNumber, description))
for nthImage, image in enumerate(images):
absoluteImageFileName = self.stepImage(stepNumber, nthImage)
relativeImageFileName = os.path.basename(absoluteImageFileName)
index.write("<img src='%s'/>\n" % (relativeImageFileName))
image.save(absoluteImageFileName)
if einfo:
index.write(cgitb.html(einfo))
index.write(
"""
</body>
</html>
"""
)
index.close()
def notify_error(self):
ex_type, ex, tb = sys.exc_info()
self.send_html({
'subject': 'Fatal Error',
'html': cgitb.html(sys.exc_info()),
'text': cgitb.text(sys.exc_info())
})
def __call_service(self, query):
"""Execute service method implemented by child class.
When either a GET or POST request is received, this method is
called with a string representing the query. Request and response
objects are created for the child's service method, and an answer
is sent back to the client with errors automatically being caught."""
request = _HttpServletRequest(query)
response = _HttpServletResponse()
# noinspection PyBroadException
try:
self.service(request, response)
except Exception:
if self.__debug:
self.send_response(500)
self.send_header('Content-Type', 'text/html')
self.send_header('Connection', 'close')
self.end_headers()
klass, value, trace = sys.exc_info()
# The next function call may raise an exception.
html = cgitb.html((klass, value, trace.tb_next))
self.wfile.write(html.encode())
else:
self.send_error(500)
else:
self.__send_response(response)
def test_html(self):
try:
raise ValueError('Hello World')
except ValueError as err:
html = cgitb.html(sys.exc_info())
self.assertIn('ValueError', html)
self.assertIn(str(err), html)
def ErrorHandler(exc_info, stream):
import cgitb
stream.write('Status: 500 fcgi error\r\n')
stream.write('Content-Type: text/html\r\n')
stream.write('\r\n')
stream.write(cgitb.html(exc_info))
stream.flush()
def send_exception_email(emailtype):
"""
If we decide to capture exceptions we can call
this to send well formated emails out with
error data and location in the script
"""
if emailtype == 'exception':
try:
if CFG.values['emailexceptions'] and CFG.values[
'emailexceptionsrecipient']:
import cgitb
emaildata = {
"emailtitle": "EMR Script Exception Error",
"date": date.today().strftime('%d, %b %Y'),
"exceptionhtml": cgitb.html(sys.exc_info())
}
EMAIL.send_email_template(
jinjatemplate='email-html_exception',
jinjadata=emaildata,
subject="EMR Script Exception Error",
recipients=str(
CFG.values['emailexceptionsrecipient']).split(';'))
except:
pass
def _actionGenericDoDelOld(self, oCoreObjectLogic, sCoreObjectIdFieldName, sRedirectAction):
"""
Delete entry (using oLogicType.remove).
@param oCoreObjectLogic A *Logic class
@param sCoreObjectIdFieldName Name of HTTP POST variable that
contains object ID information
@param sRedirectAction An action for redirect user to
in case of operation success
"""
iCoreDataObjectId = self.getStringParam(sCoreObjectIdFieldName) # STRING?!?!
self._checkForUnknownParameters()
try:
self._sPageTitle = None
self._sPageBody = None
self._sRedirectTo = self._sActionUrlBase + sRedirectAction
return oCoreObjectLogic(self._oDb).remove(self._oCurUser.uid, iCoreDataObjectId)
except Exception as oXcpt:
self._oDb.rollback();
self._sPageTitle = 'Unable to delete record'
self._sPageBody = str(oXcpt);
if config.g_kfDebugDbXcpt:
self._sPageBody += cgitb.html(sys.exc_info());
self._sRedirectTo = None
return False
def do_GET(self):
try:
self.parsed_uri = urlparse(self.path)
self.query = {}
for k, v in parse_qsl(self.parsed_uri[4]):
self.query[k] = v
self.setUser()
path = self.parsed_uri[2].lower()
if path == '/':
self.showMainPage()
elif path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/login':
self.showLoginPage('/', '/')
elif path == '/loginsubmit':
self.doLogin()
elif path.startswith('/id/'):
self.showIdPage(path)
elif path.startswith('/yadis/'):
self.showYadis(path[7:])
elif path == '/serveryadis':
self.showServerYadis()
else:
self.send_response(404)
self.end_headers()
except Exception:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
def do_POST(self):
try:
self.parsed_uri = urlparse(self.path)
self.setUser()
content_length = int(self.headers['Content-Length'])
post_data = self.rfile.read(content_length)
self.query = {}
for k, v in cgi.parse_qsl(post_data):
self.query[k] = v
path = self.parsed_uri[2]
if path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/allow':
self.handleAllow(self.query)
else:
self.send_response(404)
self.end_headers()
except (KeyboardInterrupt, SystemExit):
raise
except:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
def _actionGenericDoRemove(self, oLogicType, sParamId, sRedirAction):
"""
Delete entry (using oLogicType.removeEntry).
oLogicType is a class that implements addEntry.
sParamId is the name (ksParam_...) of the HTTP variable hold the ID of
the database entry to delete.
sRedirAction is what action to redirect to on success.
"""
import cgitb;
idEntry = self.getIntParam(sParamId, iMin = 1, iMax = 0x7ffffffe)
fCascade = self.getBoolParam('fCascadeDelete', False);
sRedirectTo = self.getRedirectToParameter(self._sActionUrlBase + sRedirAction);
self._checkForUnknownParameters()
try:
self._sPageTitle = None
self._sPageBody = None
self._sRedirectTo = sRedirectTo;
return oLogicType(self._oDb).removeEntry(self._oCurUser.uid, idEntry, fCascade = fCascade, fCommit = True);
except Exception as oXcpt:
self._oDb.rollback();
self._sPageTitle = 'Unable to delete entry';
self._sPageBody = str(oXcpt);
if config.g_kfDebugDbXcpt:
self._sPageBody += cgitb.html(sys.exc_info());
self._sRedirectTo = None;
return False;
def _actionGenericDoRemove(self, oLogicType, sParamId, sRedirAction):
"""
Delete entry (using oLogicType.removeEntry).
oLogicType is a class that implements addEntry.
sParamId is the name (ksParam_...) of the HTTP variable hold the ID of
the database entry to delete.
sRedirAction is what action to redirect to on success.
"""
import cgitb;
idEntry = self.getIntParam(sParamId, iMin = 1, iMax = 0x7ffffffe)
fCascade = self.getBoolParam('fCascadeDelete', False);
sRedirectTo = self.getRedirectToParameter(self._sActionUrlBase + sRedirAction);
self._checkForUnknownParameters()
try:
if self.isReadOnlyUser():
raise Exception('"%s" is a read only user!' % (self._oCurUser.sUsername,));
self._sPageTitle = None
self._sPageBody = None
self._sRedirectTo = sRedirectTo;
return oLogicType(self._oDb).removeEntry(self._oCurUser.uid, idEntry, fCascade = fCascade, fCommit = True);
except Exception as oXcpt:
self._oDb.rollback();
self._sPageTitle = 'Unable to delete entry';
self._sPageBody = str(oXcpt);
if config.g_kfDebugDbXcpt:
self._sPageBody += cgitb.html(sys.exc_info());
self._sRedirectTo = None;
return False;
def do_POST(self):
try:
self.parsed_uri = urlparse(self.path)
self.setUser()
content_length = int(self.headers["Content-Length"])
post_data = self.rfile.read(content_length)
self.query = {}
self.genurl = {}
for k, v in cgi.parse_qsl(post_data):
self.query[k] = v
path = self.parsed_uri[2]
if path == "/openidserver":
self.serverEndPoint(self.query)
elif path == "/allow":
self.handleAllow(self.query)
elif path == "/signin":
self.handleSignin(self.query)
elif path == "/invalid":
self.send_response(404)
else:
self.send_response(404)
self.end_headers()
except (KeyboardInterrupt, SystemExit):
raise
except:
self.send_response(500)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
def errmail_tween(request, subject=subject):
try:
return handler(request)
except Exception, e:
try:
exc_info = sys.exc_info()
mailer = get_mailer(request)
exc_repr = repr(e)[:200]
localtime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
gmtime = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
mapping = {'localtime':localtime,
'gmtime':gmtime,
'hostname':hostname,
'exception':exc_repr}
def replace(match):
whole, param1, param2 = match.groups()
return mapping.get(param1 or param2, whole)
subject = _interp_regex.sub(replace, subject)
html = cgitb.html(exc_info)
header = request.url
html = '<html><h1>%s</h1>%s</html>' % (header, html)
body = ''.join(traceback.format_exception(*exc_info))
body = '%s\n\n%s' % (header, body)
message = Message(subject=subject,
sender=sender,
recipients=recipients,
html=html,
body=body)
mailer.send_immediately(message, fail_silently=True)
raise
finally:
del exc_info
def _actionGenericDoDelOld(self, oCoreObjectLogic, sCoreObjectIdFieldName,
sRedirectAction):
"""
Delete entry (using oLogicType.remove).
@param oCoreObjectLogic A *Logic class
@param sCoreObjectIdFieldName Name of HTTP POST variable that
contains object ID information
@param sRedirectAction An action for redirect user to
in case of operation success
"""
iCoreDataObjectId = self.getStringParam(
sCoreObjectIdFieldName) # STRING?!?!
self._checkForUnknownParameters()
try:
self._sPageTitle = None
self._sPageBody = None
self._sRedirectTo = self._sActionUrlBase + sRedirectAction
return oCoreObjectLogic(self._oDb).remove(self._oCurUser.uid,
iCoreDataObjectId)
except Exception as oXcpt:
self._oDb.rollback()
self._sPageTitle = 'Unable to delete record'
self._sPageBody = str(oXcpt)
if config.g_kfDebugDbXcpt:
self._sPageBody += cgitb.html(sys.exc_info())
self._sRedirectTo = None
return False
def ErrorHandler(exc_info, stream):
import cgitb
stream.write('Status: 500 fcgi error\r\n')
stream.write('Content-Type: text/html\r\n')
stream.write('\r\n')
stream.write(cgitb.html(exc_info))
stream.flush()
def post(self):
try:
#print "in OpenID AUth service post with request: "
#print self.request
self.path = self.request.url
self.parsed_uri = urlparse(self.path)
self.setUser()
content_length = int(self.headers['Content-Length'])
post_data = self.rfile.read(content_length)
self.query = {}
for k, v in cgi.parse_qsl(post_data):
self.query[k] = v
print self.query
path = self.parsed_uri[2]
if path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/allow':
self.handleAllow(self.query)
else:
self.response.status ='404 Not Found'
except (KeyboardInterrupt, SystemExit):
raise
except:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
def show_error_web(exc_info):
try:
html = cgitb.html(exc_info)
with NamedTemporaryFile(delete=False, mode='w',
suffix='.html') as tmp_file:
tmp_file.write(html)
webbrowser.open_new_tab(Path(tmp_file.name).as_uri())
except BaseException:
# Oof. This happens sometimes with some exceptions ("AttributeError: characters_written").
try:
html = cgitb.text(exc_info)
with NamedTemporaryFile(delete=False, mode='w',
suffix='.txt') as tmp_file:
tmp_file.write(html)
webbrowser.open_new_tab(Path(tmp_file.name).as_uri())
except BaseException:
# Hm... now it's getting ridiculous.
try:
html = ''.join(traceback.format_exception(*exc_info))
with NamedTemporaryFile(delete=False, mode='w',
suffix='.txt') as tmp_file:
tmp_file.write(html)
webbrowser.open_new_tab(Path(tmp_file.name).as_uri())
except BaseException:
# Yikes!
md = SkyTempleMessageDialog(
None,
Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.ERROR,
Gtk.ButtonsType.OK,
_("Trying to display the error failed. Wow!"),
title=":(")
md.run()
md.destroy()
def do_POST(self):
try:
self.parsed_uri = urlparse(self.path)
self.setUser()
content_length = int(self.headers['Content-Length'])
post_data = self.rfile.read(content_length)
self.query = {}
for k, v in cgi.parse_qsl(post_data):
self.query[k] = v
path = self.parsed_uri[2]
if path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/allow':
self.handleAllow(self.query)
else:
self.send_response(404)
self.end_headers()
except (KeyboardInterrupt, SystemExit):
raise
except:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(
bytes(cgitb.html(sys.exc_info(), context=10), 'utf-8'))
def handleException(self, path, params, post_params):
self.sendResponse(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
msg = cgitb.html(sys.exc_info(), context=10)
print msg
# TODO. Not display the error message.
self.wfile.write(msg)
def error(self, req):
"""
Called by Request if an exception occurs within the handler. May and
should be overridden.
"""
import cgitb
req.stdout.write('Content-Type: text/html\r\n\r\n' +
cgitb.html(sys.exc_info()))
def error(self, request):
"""
Override to provide custom error handling. Ideally, however,
all errors should be caught at the application level.
"""
request.startResponse(200, 'OK', [('Content-Type', 'text/html')])
import cgitb
request.write(cgitb.html(sys.exc_info()))
def handleException(self, path, params, post_params):
self.sendResponse(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
msg = cgitb.html(sys.exc_info(), context=10)
print msg
# TODO. Not display the error message.
self.wfile.write(msg)
def error(self, req):
"""
Called by Request if an exception occurs within the handler. May and
should be overridden.
"""
import cgitb
req.stdout.write("Content-Type: text/html\r\n\r\n" + cgitb.html(sys.exc_info()))
def error(self, request):
"""
Override to provide custom error handling. Ideally, however,
all errors should be caught at the application level.
"""
import cgitb
request.stdout.write('Content-Type: text/html\r\n\r\n' +
cgitb.html(sys.exc_info()))
def except_handler(etype=None, evalue=None, etb=None):
"""
Log uncaught exceptions and display a friendly error.
"""
if not etype or not evalue or not etb:
etype, evalue, etb = sys.exc_info()
import cgitb
out(cgitb.reset())
if logdir is None:
out(error_template % """
A problem has occurred, but it probably isn't your fault.
""")
else:
import stat
import traceback
try:
doc = cgitb.html((etype, evalue, etb), 5)
except: # just in case something goes wrong
doc = ''.join(traceback.format_exception(etype, evalue, etb))
if debug:
out(doc)
return
try:
while etb.tb_next != None:
etb = etb.tb_next
e_file = etb.tb_frame.f_code.co_filename
e_line = etb.tb_frame.f_lineno
ldir = os.path.join(logdir, os.path.split(e_file)[-1])
if not os.path.exists(ldir):
os.umask(0000)
os.makedirs(ldir)
(fd, path) = tempfile.mkstemp(prefix="%s_" % e_line,
suffix='.html',
dir=ldir)
fh = os.fdopen(fd, 'w')
fh.write(doc)
fh.close()
os.chmod(path, stat.S_IROTH)
out(error_template % """\
A problem has occurred, but it probably isn't your fault.
RED has remembered it, and we'll try to fix it soon.""")
except:
out(error_template % """\
A problem has occurred, but it probably isn't your fault.
RED tried to save it, but it couldn't! Oops.<br>
Please e-mail the information below to
<a href='mailto:[email protected]'>[email protected]</a>
and we'll look into it.""")
out("<h3>Original Error</h3>")
out("<pre>")
out(''.join(traceback.format_exception(etype, evalue, etb)))
out("</pre>")
out("<h3>Write Error</h3>")
out("<pre>")
etype, value, tb = sys.exc_info()
out(''.join(traceback.format_exception(etype, value, tb)))
out("</pre>")
sys.exit(1) # We're in an uncertain state, so we must die horribly.
def errorPage(self, sError, aXcptInfo, sLogFile = None):
"""
Displays a page with an error message.
"""
if sLogFile is not None:
self.errorLog(sError, aXcptInfo, sLogFile);
# Reset buffering, hoping that nothing was flushed yet.
self._sBodyType = None;
self._sHtmlBody = '';
self._cchCached = 0;
if not self._fHeaderWrittenOut:
if self._fHtmlDebugOutput:
self.setHeaderField('Content-Type', 'text/html; charset=utf-8');
else:
self.setHeaderField('Content-Type', 'text/plain; charset=utf-8');
# Write the error page.
if self._fHtmlDebugOutput:
self.write('<html><head><title>Test Manage Error</title></head>\n' +
'<body><h1>Test Manager Error:</h1>\n' +
'<p>' + sError + '</p>\n');
else:
self.write(' Test Manage Error\n'
'===================\n'
'\n'
'' + sError + '\n\n');
if aXcptInfo[0] is not None:
if self._fHtmlDebugOutput:
self.write('<h1>Backtrace:</h1>\n');
self.write(cgitb.html(aXcptInfo, 5));
else:
self.write('Backtrace\n'
'---------\n'
'\n');
self.write(cgitb.text(aXcptInfo, 5));
self.write('\n\n');
if self.kfDebugInfoEnabled:
if self._fHtmlDebugOutput:
self.write('<h1>Debug Info:</h1>\n');
else:
self.write('Debug Info\n'
'----------\n'
'\n');
self.debugDumpStuff();
for fn in self._afnDebugInfo:
try:
fn(self, self._fHtmlDebugOutput);
except Exception as oXcpt:
self.write('\nDebug info callback %s raised exception: %s\n' % (fn, oXcpt));
if self._fHtmlDebugOutput:
self.write('</body></html>');
self.flush();
def errorPage(self, sError, aXcptInfo, sLogFile = None):
"""
Displays a page with an error message.
"""
if sLogFile is not None:
self.errorLog(sError, aXcptInfo, sLogFile);
# Reset buffering, hoping that nothing was flushed yet.
self._sBodyType = None;
self._sHtmlBody = '';
self._cchCached = 0;
if not self._fHeaderWrittenOut:
if self._fHtmlDebugOutput:
self.setHeaderField('Content-Type', 'text/html; charset=utf-8');
else:
self.setHeaderField('Content-Type', 'text/plain; charset=utf-8');
# Write the error page.
if self._fHtmlDebugOutput:
self.write('<html><head><title>Test Manage Error</title></head>\n' +
'<body><h1>Test Manager Error:</h1>\n' +
'<p>' + sError + '</p>\n');
else:
self.write(' Test Manage Error\n'
'===================\n'
'\n'
'' + sError + '\n\n');
if aXcptInfo[0] is not None:
if self._fHtmlDebugOutput:
self.write('<h1>Backtrace:</h1>\n');
self.write(cgitb.html(aXcptInfo, 5));
else:
self.write('Backtrace\n'
'---------\n'
'\n');
self.write(cgitb.text(aXcptInfo, 5));
self.write('\n\n');
if self.kfDebugInfoEnabled:
if self._fHtmlDebugOutput:
self.write('<h1>Debug Info:</h1>\n');
else:
self.write('Debug Info\n'
'----------\n'
'\n');
self.debugDumpStuff();
for fn in self._afnDebugInfo:
try:
fn(self, self._fHtmlDebugOutput);
except Exception as oXcpt:
self.write('\nDebug info callback %s raised exception: %s\n' % (fn, oXcpt));
if self._fHtmlDebugOutput:
self.write('</body></html>');
self.flush();
def except_handler(etype=None, evalue=None, etb=None):
"""
Log uncaught exceptions and display a friendly error.
"""
if not etype or not evalue or not etb:
etype, evalue, etb = sys.exc_info()
import cgitb
out(cgitb.reset())
if logdir is None:
out(error_template % """
A problem has occurred, but it probably isn't your fault.
""")
else:
import stat
import traceback
try:
doc = cgitb.html((etype, evalue, etb), 5)
except: # just in case something goes wrong
doc = ''.join(traceback.format_exception(etype, evalue, etb))
if debug:
out(doc)
return
try:
while etb.tb_next != None:
etb = etb.tb_next
e_file = etb.tb_frame.f_code.co_filename
e_line = etb.tb_frame.f_lineno
ldir = os.path.join(logdir, os.path.split(e_file)[-1])
if not os.path.exists(ldir):
os.umask(0000)
os.makedirs(ldir)
(fd, path) = tempfile.mkstemp(
prefix="%s_" % e_line, suffix='.html', dir=ldir
)
fh = os.fdopen(fd, 'w')
fh.write(doc)
fh.close()
os.chmod(path, stat.S_IROTH)
out(error_template % """\
A problem has occurred, but it probably isn't your fault.
RED has remembered it, and we'll try to fix it soon.""")
except:
out(error_template % """\
A problem has occurred, but it probably isn't your fault.
RED tried to save it, but it couldn't! Oops.<br>
Please e-mail the information below to
<a href='mailto:[email protected]'>[email protected]</a>
and we'll look into it.""")
out("<h3>Original Error</h3>")
out("<pre>")
out(''.join(traceback.format_exception(etype, evalue, etb)))
out("</pre>")
out("<h3>Write Error</h3>")
out("<pre>")
etype, value, tb = sys.exc_info()
out(''.join(traceback.format_exception(etype, value, tb)))
out("</pre>")
sys.exit(1) # We're in an uncertain state, so we must die horribly.
def handleRequest(self):
try:
value = self.processRequest()
self._startResponse(self.status, self.headers)
return value
except:
import cgitb
self._startResponse("500 Internal Server Error", [('Content-Type', 'text/html')])
return cgitb.html(sys.exc_info())
def test_html(self):
try:
raise ValueError("Hello World")
except ValueError as err:
# If the html was templated we could do a bit more here.
# At least check that we get details on what we just raised.
html = cgitb.html(sys.exc_info())
self.assertIn("ValueError", html)
self.assertIn(str(err), html)
def test_html(self):
try:
raise ValueError("Hello World")
except ValueError as err:
# If the html was templated we could do a bit more here.
# At least check that we get details on what we just raised.
html = cgitb.html(sys.exc_info())
self.assertIn("ValueError", html)
self.assertIn(str(err), html)
def application(environ, start_response):
"""
Entry point for wsgi.
"""
## Needed for mod_wsgi, see: <http://code.google.com/p/modwsgi/wiki/ApplicationIssues>
req = SimulatedModPythonRequest(environ, start_response)
#print 'Starting mod_python simulation'
try:
try:
possible_module, possible_handler = is_mp_legacy_publisher_path(
environ['PATH_INFO'])
if possible_module is not None:
mp_legacy_publisher(req, possible_module, possible_handler)
elif CFG_WSGI_SERVE_STATIC_FILES:
possible_static_path = is_static_path(environ['PATH_INFO'])
if possible_static_path is not None:
from invenio.bibdocfile import stream_file
stream_file(req, possible_static_path)
else:
ret = invenio_handler(req)
else:
ret = invenio_handler(req)
req.flush()
except SERVER_RETURN, status:
status = int(str(status))
if status not in (OK, DONE):
req.status = status
req.headers_out['content-type'] = 'text/html'
admin_to_be_alerted = alert_admin_for_server_status_p(
status, req.headers_in.get('referer'))
if admin_to_be_alerted:
register_exception(req=req, alert_admin=True)
if not req.response_sent_p:
start_response(req.get_wsgi_status(),
req.get_low_level_headers(), sys.exc_info())
return generate_error_page(req, admin_to_be_alerted)
else:
req.flush()
except:
register_exception(req=req, alert_admin=True)
if not req.response_sent_p:
req.status = HTTP_INTERNAL_SERVER_ERROR
req.headers_out['content-type'] = 'text/html'
start_response(req.get_wsgi_status(),
req.get_low_level_headers(), sys.exc_info())
if CFG_DEVEL_SITE:
return [
"<pre>%s</pre>" % cgi.escape(
get_pretty_traceback(req=req,
exc_info=sys.exc_info()))
]
from cgitb import html
return [html(sys.exc_info())]
return generate_error_page(req)
else:
return generate_error_page(req, page_already_started=True)
def error_output(self, environ, start_response):
"""WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
"""
start_response('500 Internal Server Error', [('Content-Type','text/html')], sys.exc_info())
return [cgitb.html(sys.exc_info())]
def render(self):
etype, value, tb = sys.exc_info()
if isinstance(value, openobject.errors.Concurrency):
return self.__render(value)
if not isinstance(value, openobject.errors.TinyException):
return cgitb.html((etype, value, tb))
return self.__render(value)
def _displayDebugPage(self, environ, start_response):
"""
When debugging, display an informative traceback of the exception.
"""
import cgitb
result = [cgitb.html(sys.exc_info())]
start_response('200 OK', [('Content-Type', 'text/html'),
('Content-Length', str(len(result[0])))],
sys.exc_info())
return result
def render(self):
etype, value, tb = sys.exc_info()
if isinstance(value, common.Concurrency):
return self.__render(value)
if not isinstance(value, common.TinyException):
return cgitb.html((etype, value, tb))
return self.__render(value)
def do_POST(self):
"""Handle all HTTP POST requests"""
try:
self.parsed_uri = urlparse(self.path)
content_length = int(self.headers['Content-Length'])
post_data = self.rfile.read(content_length)
self.query = {}
for (key, val) in cgi.parse_qsl(post_data):
# print "DEBUG: checking post input arg %s: '%s'" % (key, val)
validate_helper = self.validators.get(key, invalid_argument)
# Let validation errors pass to general exception handler below
validate_helper(val)
self.query[key] = val
self.setUser()
# print "DEBUG: checking path '%s'" % self.parsed_uri[2]
valid_path(self.parsed_uri[2])
path = self.parsed_uri[2]
# Strip server_base before testing location
path = path.replace("%s/" % self.server.server_base, '', 1)
if path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/allow':
self.handleAllow(self.query)
else:
self.send_response(404)
self.end_headers()
except (KeyboardInterrupt, SystemExit):
raise
except:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
print "ERROR: %s" % cgitb.html(sys.exc_info(), context=10)
def whatever():
try:
foo = 'bar'
baz = 1 / 0
except Exception:
html_output = cgitb.html(sys.exc_info())
# Write a file so we can look at it
open('error.html', 'w').write(html_output)
# open a webbrowser to look at it
webbrowser.open('file:///%s' % os.path.join(os.getcwd(), 'error.html'))
def _tb2html(tbt, tbv, tb):
if sys.hexversion < 0x2020000:
from reportPackages.rlextra.utils.cgisupport import quoteValue
import traceback
html = quoteValue('\n'.join(
traceback.format_tb(tb) + ['%s: %s' % (str(tbt), str(tbv))]))
else:
import cgitb
html = cgitb.html((tbt, tbv, tb), context=None)
html = html[html.find('>') + 1:html.find('<!-- The above')]
return '<pre>%s</pre>' % html
def error_output(self, environ, start_response):
"""WSGI mini-app to create error output
By default, this just uses the 'error_status', 'error_headers',
and 'error_body' attributes to generate an output page. It can
be overridden in a subclass to dynamically generate diagnostics,
choose an appropriate message for the user's preferred language, etc.
"""
start_response('500 Internal Server Error',
[('Content-Type', 'text/html')], sys.exc_info())
return [cgitb.html(sys.exc_info())]
def do_GET(self):
try:
self.parsed_uri = urlparse(self.path)
self.query = {}
for k, v in cgi.parse_qsl(self.parsed_uri[4]):
self.query[k] = v
print self.headers
try:
client_ip = self.headers['X-Forwarded-For']
except:
self.send_error(501, 'Server error: %s' % self.path)
print "No X-Forwarded-For header. You are NOT facing gpgopenid directly to the Internet, aren't you?"
return
if 'true' != self.headers['X-Auth-OpenPGP'].lower().strip():
self.send_error(401,
"The http request was not signed by EnigForm")
print "X-Auth-OpenPGP : false. The http headers were not signed by Enigform"
return
self.gpgkeyid = self.headers['X-Auth-OpenPGP-KeyID']
self.setUser()
path = self.parsed_uri[2].lower()
if path == '/':
self.showMainPage()
elif path == '/openidserver':
self.serverEndPoint(self.query)
elif path == '/login':
self.showLoginPage('/', '/')
elif path == '/loginsubmit':
self.doLogin()
elif path.startswith('/id/'):
self.showIdPage(path)
elif path.startswith('/yadis/'):
self.showYadis(path[7:])
elif path == '/serveryadis':
self.showServerYadis()
else:
self.send_response(404)
self.end_headers()
except (KeyboardInterrupt, SystemExit):
raise
except:
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info(), context=10))
def wrapped():
try:
f()
except:
config_dump = getattr(config, "htmlDump", "")
config_dump = config_dump and config_dump()
html_formatted_info = "%s<br />%s" % (cgitb.html(sys.exc_info()), config_dump)
dump_and_open_in_browser(html_formatted_info)
# TODO: email breakage info to maintainer
raise
def err_tb():
"""
replace the default error response
with an cgitb HTML traceback
"""
import cgitb, sys
tb = cgitb.html(sys.exc_info())
def set_tb():
""" set the traceback output """
cherrypy.response.body = tb
cherrypy.response.headers['Content-Length'] = None
cherrypy.request.hooks.attach('after_error_response', set_tb)
def __init__(self, exc_type, exc_obj, exc_tb, title=None):
QDialog.__init__(self)
self.ui = Ui_ExceptHookDialog()
self.ui.setupUi(self)
if title:
self.setWindowTitle(self.windowTitle() + ": " + title)
self.ui.detailsButton.setCheckable(True)
msg = "%s: %s" % (exc_type.__name__, exc_obj)
self.ui.exceptionLabel.setText(msg)
html = cgitb.html((exc_type, exc_obj, exc_tb))
self.ui.tracebackBrowser.setText(html)
self.resize(self.sizeHint())
def cgi_error_handler(environ, start_response, app):
try:
return app(environ, start_response)
except (KeyboardInterrupt, SystemExit):
raise
except Exception as e:
headers = {'status': '500 Oops', 'content-type': 'text/html'}
start_response(headers['status'], list(headers.items()), sys.exc_info())
log('ERROR: %s' % repr(e), force=True)
return [cgitb.html(sys.exc_info())]
def whatever():
try:
foo = 'bar'
baz = 1/0
except Exception:
html_output = cgitb.html(sys.exc_info())
# Write a file so we can look at it
open('error.html', 'w').write(html_output)
# open a webbrowser to look at it
webbrowser.open(
'file:///%s' % os.path.join(os.getcwd(), 'error.html'))
def wrapped():
try:
f()
except:
config_dump = getattr(config, 'htmlDump', '')
config_dump = config_dump and config_dump()
html_formatted_info = "%s<br />%s" % (cgitb.html(
sys.exc_info()), config_dump)
dump_and_open_in_browser(html_formatted_info)
# TODO: email breakage info to maintainer
raise
def send_mail_on_exception(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception, e:
import sys, cgitb
from pnr_utils import send_email
send_email(
message=u'{} \n\n {}'.format(e.message, cgitb.html(sys.exc_info())),
subject='Py-PNR-Status Error!',
to_addr='*****@*****.**'
)
raise
def err_tb():
"""
replace the default error response
with an cgitb HTML traceback
"""
import cgitb
tb = cgitb.html(sys.exc_info())
def set_tb():
""" set the traceback output """
cherrypy.response.body = tb
cherrypy.response.headers['Content-Length'] = None
cherrypy.request.hooks.attach('after_error_response', set_tb)
def exception_to_text(exc_info=None):
"Return current exception as text, or '' if no current exception."
if exc_info is None:
exc_info = sys.exc_info()
if exc_info[0] is None:
return '' # no current exception
if hasattr(cgitb, 'text'):
txt = cgitb.text(exc_info)
else:
# eariler Pythons lack .text() ...
# this will be ugly, but its the best I can safely do
txt = cgitb.html(exc_info)
return txt
def _error(self, status=500, body_data=('', '', '')):
"""
This is an internal method used to print an error to the browser and log
it in the wsgi log.
"""
if self.Debug:
resource = {
'statuscode' : status,
'type' : 'text/html',
'data' : cgitb.html(body_data),
}
self.send(resource, 'outbox')
else:
self.send(ErrorPages.getErrorPage(status, 'An internal error has occurred.'), 'outbox')
self.log.write(''.join(traceback.format_exception(body_data[0], body_data[1], body_data[2], '\n')))
def handle_mothballer(self):
category = self.req.get("cat")
try:
catdir = self.server.args["puzzles_dir"].joinpath(category)
mb = mothballer.package(category, catdir, self.seed)
except:
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=\"utf-8\"")
self.end_headers()
self.wfile.write(cgitb.html(sys.exc_info()))
return
self.send_response(200)
self.send_header("Content-Type", "application/octet_stream")
self.end_headers()
shutil.copyfileobj(mb, self.wfile)
async def exception_middleware(request, handler):
try:
return await handler(request)
except Exception as err:
import cgitb
context = 10
if "/api" in request.path:
return web.json_response({
"ERROR":
str(err),
"tb":
cgitb.text(sys.exc_info(), context=context)
})
else:
return web.Response(text=cgitb.html(sys.exc_info(),
context=context),
content_type='text/html')
def _actionRegenQueuesCommon(self):
"""
Common code for ksActionTestBoxesRegenQueues and ksActionTestCfgRegenQueues.
Too lazy to put this in some separate place right now.
"""
self._checkForUnknownParameters()
## @todo should also be changed to a POST with a confirmation dialog preceeding it.
self._sPageTitle = 'Regenerate All Scheduling Queues'
self._sPageBody = ''
aoGroups = SchedGroupLogic(self._oDb).getAll()
for oGroup in aoGroups:
self._sPageBody += '<h3>%s (ID %#d)</h3>' % (webutils.escapeElem(
oGroup.sName), oGroup.idSchedGroup)
try:
(aoErrors, asMessages) = SchedulerBase.recreateQueue(
self._oDb, self._oCurUser.uid, oGroup.idSchedGroup, 2)
except Exception as oXcpt:
self._oDb.rollback()
self._sPageBody += '<p>SchedulerBase.recreateQueue threw an exception: %s</p>' \
% (webutils.escapeElem(str(oXcpt)),)
self._sPageBody += cgitb.html(sys.exc_info())
else:
if len(aoErrors) == 0:
self._sPageBody += '<p>Successfully regenerated.</p>'
else:
for oError in aoErrors:
if oError[1] is None:
self._sPageBody += '<p>%s.</p>' % (
webutils.escapeElem(oError[0]), )
## @todo links.
#elif isinstance(oError[1], TestGroupData):
# self._sPageBody += '<p>%s.</p>' % (webutils.escapeElem(oError[0]),);
#elif isinstance(oError[1], TestGroupCase):
# self._sPageBody += '<p>%s.</p>' % (webutils.escapeElem(oError[0]),);
else:
self._sPageBody += '<p>%s. [Cannot link to %s]</p>' \
% (webutils.escapeElem(oError[0]), webutils.escapeElem(str(oError[1])))
for sMsg in asMessages:
self._sPageBody += '<p>%s<p>\n' % (
webutils.escapeElem(sMsg), )
return True
