def _process_error(self, reason): """ Called when there is an error processing the request. *reason* (``twisted.internet.failure.Failure``) is the reason for failure. """ try: if not isinstance(reason, failure.Failure): # LIES! This is not an error. return # Log errors. log.err(reason, str(self)) if self._disconnected or self.finished: # Since we are disconnected, return and do nothing. return if self._resp_error_cb: # Call error callback. try: self._resp_error_cb(self, reason, self._resp_started, *self._resp_error_args, **self._resp_error_kw) except Exception as e: log.err(e, str(self)) if not self._resp_started: # Display Internal Server Error. code = http.INTERNAL_SERVER_ERROR if self.site.displayTracebacks: body = _server_traceback_html.format( path=urllib.escape(self.uri), traceback=webutil.formatFailure(reason)) else: body = _server_error_html.format( path=urllib.escape(self.uri)) self.setResponseCode(code) self.setResponseEncoding(self._resp_enc or 'UTF-8') self.write(body) elif 'text/html' in self.responseHeaders.getRawHeaders( 'content-type', ('', ))[0]: # Since an error occured but we've already started writing the # response, do what we can. if self.site.displayTracebacks: body = _server_traceback_html.format( path=urllib.escape(self.uri), traceback=webutil.formatFailure(reason)) else: body = "<h1>...Internal Server Error!</h1>" self.write(body) except Exception as e: log.err(e, str(self)) finally: self.finish()
def _process_error(self, reason): """ Called when there is an error processing the request. *reason* (``twisted.internet.failure.Failure``) is the reason for failure. """ try: if not isinstance(reason, failure.Failure): # LIES! This is not an error. return # Log errors. log.err(reason, str(self)) if self._disconnected or self.finished: # Since we are disconnected, return and do nothing. return if self._resp_error_cb: # Call error callback. try: self._resp_error_cb(self, reason, self._resp_started, *self._resp_error_args, **self._resp_error_kw) except Exception as e: log.err(e, str(self)) if not self._resp_started: # Display Internal Server Error. code = http.INTERNAL_SERVER_ERROR if self.site.displayTracebacks: body = _server_traceback_html.format(path=urllib.escape(self.uri), traceback=webutil.formatFailure(reason)) else: body = _server_error_html.format(path=urllib.escape(self.uri)) self.setResponseCode(code) self.setResponseEncoding(self._resp_enc or 'UTF-8') self.write(body) elif 'text/html' in self.responseHeaders.getRawHeaders('content-type', ('',))[0]: # Since an error occured but we've already started writing the # response, do what we can. if self.site.displayTracebacks: body = _server_traceback_html.format(path=urllib.escape(self.uri), traceback=webutil.formatFailure(reason)) else: body = "<h1>...Internal Server Error!</h1>" self.write(body) except Exception as e: log.err(e, str(self)) finally: self.finish()
def failed(self, why): # This can either be a BuildStepFailed exception/failure, meaning we # should call self.finished, or it can be a real exception, which should # be recorded as such. if why.check(BuildStepFailed): self.finished(FAILURE) return log.err(why, "BuildStep.failed; traceback follows") try: if self.progress: self.progress.finish() self.addHTMLLog("err.html", formatFailure(why)) self.addCompleteLog("err.text", why.getTraceback()) # could use why.getDetailedTraceback() for more information self.step_status.setText([self.name, "exception"]) self.step_status.setText2([self.name]) self.step_status.stepFinished(EXCEPTION) hidden = self._maybeEvaluate(self.hideStepIf, EXCEPTION, self) self.step_status.setHidden(hidden) except: log.msg("exception during failure processing") log.err() # the progress stuff may still be whacked (the StepStatus may # think that it is still running), but the build overall will now # finish try: self.releaseLocks() except: log.msg("exception while releasing locks") log.err() log.msg("BuildStep.failed now firing callback") self.deferred.callback(EXCEPTION)
def addLogWithFailure(self, why, logprefix=""): # helper for showing exceptions to the users try: yield self.addCompleteLog(logprefix + "err.text", why.getTraceback()) yield self.addHTMLLog(logprefix + "err.html", formatFailure(why)) except Exception: log.err(Failure(), "error while formatting exceptions")
def failed(self, why): # This can either be a BuildStepFailed exception/failure, meaning we # should call self.finish, or it can be a real exception, which should # be recorded as such. if why.check(BuildStepFailed): self.finished(FAILURE) return log.err(why, "BuildStep.failed; traceback follows") try: if self.progress: self.progress.finish() self.addHTMLLog("err.html", formatFailure(why)) self.addCompleteLog("err.text", why.getTraceback()) # could use why.getDetailedTraceback() for more information self.step_status.setText([self.name, "exception"]) self.step_status.setText2([self.name]) self.step_status.stepFinished(EXCEPTION) except: log.msg("exception during failure processing") log.err() # the progress stuff may still be whacked (the StepStatus may # think that it is still running), but the build overall will now # finish try: self.releaseLocks() except: log.msg("exception while releasing locks") log.err() log.msg("BuildStep.failed now firing callback") self.deferred.callback(EXCEPTION)
def failed(self, why): # if isinstance(why, pb.CopiedFailure): # a remote exception might # only have short traceback, so formatFailure is not as useful as # you'd like (no .frames, so no traceback is displayed) log.msg("BuildStep.failed, traceback follows") log.err(why) try: if self.progress: self.progress.finish() self.addHTMLLog("err.html", formatFailure(why)) self.addCompleteLog("err.text", why.getTraceback()) # could use why.getDetailedTraceback() for more information self.step_status.setText([self.name, "exception"]) self.step_status.setText2([self.name]) self.step_status.stepFinished(EXCEPTION) except: log.msg("exception during failure processing") log.err() # the progress stuff may still be whacked (the StepStatus may # think that it is still running), but the build overall will now # finish try: self.releaseLocks() except: log.msg("exception while releasing locks") log.err() log.msg("BuildStep.failed now firing callback") self.deferred.callback(EXCEPTION)
def processingFailed(self, reason): """ Finish this request with an indication that processing failed and possibly display a traceback. @param reason: Reason this request has failed. @type reason: L{twisted.python.failure.Failure} @return: The reason passed to this method. @rtype: L{twisted.python.failure.Failure} """ self._log.failure('', failure=reason) if self.site.displayTracebacks: body = (b"<html><head><title>web.Server Traceback" b" (most recent call last)</title></head>" b"<body><b>web.Server Traceback" b" (most recent call last):</b>\n\n" + util.formatFailure(reason) + b"\n\n</body></html>\n") else: body = (b"<html><head><title>Processing Failed" b"</title></head><body>" b"<b>Processing Failed</b></body></html>") self.setResponseCode(http.INTERNAL_SERVER_ERROR) self.setHeader(b'content-type', b"text/html") self.setHeader(b'content-length', intToBytes(len(body))) self.write(body) self.finish() return reason
def _get_error_body(self, request, failure): if self.debug_handler and self.debug_handler.is_client_allowed_debugging(request): ajax_endpoint = request.childLink("__debug__/" + self.debug_handler.register_failure(failure)) debug_variables = dict(ajax_endpoint=ajax_endpoint, body=web_util.formatFailure(failure)) html = DEBUG_HTML_TEMPLATE % debug_variables return html return STANDARD_HTML_TEMPLATE
def processingFailed(self, reason): log.err(reason) body = ("<html><head><title>web.Server Traceback (most recent call last)</title></head>" "<body><b>web.Server Traceback (most recent call last):</b>\n\n" "%s\n\n</body></html>\n" % webutil.formatFailure(reason)) self.setResponseCode(http.INTERNAL_SERVER_ERROR) self.setHeader('content-type',"text/html") self.setHeader('content-length', str(len(body))) self.write(body) self.finish() return reason
def test_returnsBytes(self): """ The return value of L{formatFailure} is a C{str} instance (not a C{unicode} instance) with numeric character references for any non-ASCII characters meant to appear in the output. """ try: raise Exception("Fake bug") except: result = formatFailure(Failure()) self.assertIsInstance(result, bytes) self.assertTrue(all(ch < 128 for ch in result)) # Indentation happens to rely on NO-BREAK SPACE self.assertIn(b" ", result)
def test_returnsBytes(self): """ The return value of L{formatFailure} is a C{str} instance (not a C{unicode} instance) with numeric character references for any non-ASCII characters meant to appear in the output. """ try: raise Exception("Fake bug") except: result = formatFailure(Failure()) self.assertIsInstance(result, str) self.assertTrue(all(ord(ch) < 128 for ch in result)) # Indentation happens to rely on NO-BREAK SPACE self.assertIn(" ", result)
def processingFailed(self, reason): log.err(reason) if self.site.displayTracebacks: body = ( "<html><head><title>web.Server Traceback (most recent call last)</title></head>" "<body><b>web.Server Traceback (most recent call last):</b>\n\n" "%s\n\n</body></html>\n" % webutil.formatFailure(reason)) else: body = ("<html><head><title>Processing Failed</title></head><body>" "<b>Processing Failed</b></body></html>") self.setResponseCode(http.INTERNAL_SERVER_ERROR) self.setHeader('content-type', "text/html") self.setHeader('content-length', str(len(body))) self.write(body) self.finish() return reason
def failed(self, why): # This can either be a BuildStepFailed exception/failure, meaning we # should call self.finished, or it can be a real exception, which should # be recorded as such. if why.check(BuildStepFailed): self.finished(FAILURE) return # However, in the case of losing the connection to a slave, we want to # finish with a RETRY. if why.check(error.ConnectionLost): self.step_status.setText(self.describe(True) + ["exception", "slave", "lost"]) self.step_status.setText2(["exception", "slave", "lost"]) self.finished(RETRY) return log.err(why, "BuildStep.failed; traceback follows") try: if self.progress: self.progress.finish() try: self.addCompleteLog("err.text", why.getTraceback()) self.addHTMLLog("err.html", formatFailure(why)) except Exception: log.err(Failure(), "error while formatting exceptions") # could use why.getDetailedTraceback() for more information self.step_status.setText([self.name, "exception"]) self.step_status.setText2([self.name]) self.step_status.stepFinished(EXCEPTION) hidden = self._maybeEvaluate(self.hideStepIf, EXCEPTION, self) self.step_status.setHidden(hidden) except Exception: log.err(Failure(), "exception during failure processing") # the progress stuff may still be whacked (the StepStatus may # think that it is still running), but the build overall will now # finish try: self.releaseLocks() except Exception: log.err(Failure(), "exception while releasing locks") log.msg("BuildStep.failed now firing callback") self.deferred.callback(EXCEPTION)
def failed(self, why): # This can either be a BuildStepFailed exception/failure, meaning we # should call self.finished, or it can be a real exception, which should # be recorded as such. if why.check(BuildStepFailed): self.finished(FAILURE) return klog.err_json(why, "BuildStep.failed; traceback follows") results = EXCEPTION try: if self.progress: self.progress.finish() try: self.addCompleteLog("err.text", why.getTraceback()) self.addHTMLLog("err.html", formatFailure(why)) except AttributeError: klog.err_json( Failure(), "DEBUG formatting exc. why.type: %s %s" % (why.type, type(why.type))) except Exception: klog.err_json(Failure(), "error while formatting exceptions") # could use why.getDetailedTraceback() for more information self.step_status.setText(["'%s'" % self.name, "exception"]) self.step_status.setText2(["'%s'" % self.name]) if isinstance(why, Failure) and (why.type == pb.PBConnectionLost or why.type == error.ConnectionLost): results = RETRY self.step_status.stepFinished(results) hidden = self._maybeEvaluate(self.hideStepIf, EXCEPTION, self) self.step_status.setHidden(hidden) except Exception: klog.err_json(Failure(), "exception during failure processing") # the progress stuff may still be whacked (the StepStatus may # think that it is still running), but the build overall will now # finish try: self.releaseLocks() except Exception: klog.err_json(Failure(), "exception while releasing locks") log.msg("BuildStep.failed now firing callback") self.deferred.callback(results)
def processingFailed(self, reason): log.err(reason) # Re-enable on Python 3 as part of #6178: if not _PY3 and self.site.displayTracebacks: body = ("<html><head><title>web.Server Traceback (most recent call last)</title></head>" "<body><b>web.Server Traceback (most recent call last):</b>\n\n" "%s\n\n</body></html>\n" % webutil.formatFailure(reason)) else: body = (b"<html><head><title>Processing Failed</title></head><body>" b"<b>Processing Failed</b></body></html>") self.setResponseCode(http.INTERNAL_SERVER_ERROR) self.setHeader(b'content-type', b"text/html") self.setHeader(b'content-length', intToBytes(len(body))) self.write(body) self.finish() return reason
def _finishFinished(self, results): # internal function to indicate that this step is done; this is separated # from finished() so that subclasses can override finished() if self.progress: self.progress.finish() try: hidden = self._maybeEvaluate(self.hideStepIf, results, self) except Exception: why = Failure() self.addHTMLLog("err.html", formatFailure(why)) self.addCompleteLog("err.text", why.getTraceback()) results = EXCEPTION hidden = False self.step_status.stepFinished(results) self.step_status.setHidden(hidden) self.releaseLocks() self.deferred.callback(results)
def processingFailed(self, reason): log.err(reason) if self.site.displayTracebacks: body = (b"<html><head><title>web.Server Traceback" b" (most recent call last)</title></head>" b"<body><b>web.Server Traceback" b" (most recent call last):</b>\n\n" + util.formatFailure(reason) + b"\n\n</body></html>\n") else: body = (b"<html><head><title>Processing Failed" b"</title></head><body>" b"<b>Processing Failed</b></body></html>") self.setResponseCode(http.INTERNAL_SERVER_ERROR) self.setHeader(b'content-type', b"text/html") self.setHeader(b'content-length', intToBytes(len(body))) self.write(body) self.finish() return reason
def mailFailure(self, event): if not event['isError']: return body = None if 'failure' in event: body = ( "<html><head><title>EPP Proxy Traceback (most recent call last)</title></head>" "<body><b>EPP Proxy Traceback (most recent call last):</b>\n\n" "%s\n\n</body></html>\n" % webutil.formatFailure(event['failure'])) else: body = str(event['message']) msg = MIMEMultipart() msg['From'] = conf.MAIL_FROM msg['To'] = ','.join(conf.MAIL_TO_ON_ERROR) #msg['Date'] = email_utils.formatdate() if 'failure' in event: msg['Subject'] = self.hostname + ' - EPP Proxy Failure' else: msg['Subject'] = self.hostname + ' - EPP Proxy Message' html_part = MIMEBase('text', 'html') html_part.set_payload(body) msg.attach(html_part) msg_data = msg.as_string(unixfrom=False) def _success(ignore): pass def _fail(reason): pass d = smtp.sendmail(conf.SMTP_HOST, conf.MAIL_FROM, conf.MAIL_TO_ON_ERROR, msg_data) d.addCallbacks(_success, _fail)
def renderFailure(fail, request): if not fail: fail = failure.Failure() log.err(fail) request.write(webutil.formatFailure(fail))
def addErrorResult(self, why): self.addHTMLLog("err.html", formatFailure(why)) self.addCompleteLog("err.text", why.getTraceback()) results = EXCEPTION hidden = False return hidden, results
start_response('503 Service Unavailable', headers) return content except: reason = failure.Failure() reason.printTraceback(env['wsgi.errors']) if('modu.app' in req and req.app.config.get('error_content')): content_provider = req.app.error_content() req['modu.failure'] = reason content_provider.prepare_content(req) content = [content_provider.get_content(req)] headers = [('Content-Type', content_provider.get_content_type(req))] else: content = ["<html><head><title>web.Server Traceback (most recent call last)</title></head>" "<body><b>web.Server Traceback (most recent call last):</b>\n\n" "%s\n\n</body></html>\n" % util.formatFailure(reason)] headers = [('Content-Type', 'text/html')] start_response('500 Internal Server Error', headers) return content start_response('200 OK', req.get_headers()) return content def check_maintenance_mode(req): """ Check whether maintenance mode is on or not. At this time, this merely checks for the existence of a 'modu-maintenance' file in /etc. There are a significant limitations with this implementation: