Python util.formatFailure函数代码示例

	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 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 _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, str)
        self.assertTrue(all(ord(ch) < 128 for ch in result))
        # Indentation happens to rely on NO-BREAK SPACE
        self.assertIn("&#160;", result)

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

		
		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: