def _ebDeferSetUp(self, failure, result):
     if failure.check(SkipTest):
         result.addSkip(self, self._getSkipReason(self.setUp, failure.value))
     else:
         result.addError(self, failure)
         if failure.check(KeyboardInterrupt):
             result.stop()
     return self.deferRunCleanups(None, result)

 def _ebDeferSetUp(self, failure, result):
     if failure.check(SkipTest):
         result.addSkip(self, self._getReason(failure))
     else:
         result.addError(self, failure)
         result.upDownError("setUp", failure, warn=False, printStatus=False)
         if failure.check(KeyboardInterrupt):
             result.stop()

 def eb(failure):
     # FIXME
     if failure.check(errors.NoMethodError) \
         or failure.check(flavors.NoSuchMethod):
         common.errorRaise("No method '%s' on manager." % methodName)
     elif failure.check(errors.RemoteRunError):
         common.errorRaise(log.getFailureMessage(failure))
     else:
         common.errorRaise(log.getFailureMessage(failure))

 def eb(failure):
     if failure.check(errors.NoMethodError):
         common.errorRaise("No method '%s' on component '%s'." % (
             methodName, p.componentId))
     elif failure.check(errors.SleepingComponentError):
         common.errorRaise(
             "Component '%s' is sleeping." % p.componentId)
     else:
         common.errorRaise(log.getFailureMessage(failure))

 def eb(failure):
     # FIXME
     if failure.check(errors.NoMethodError):
         common.errorRaise("No method '%s' on worker '%s'." % (methodName, workerName))
     elif failure.check(errors.SleepingComponentError):
         common.errorRaise("Component '%s' is sleeping." % p.componentId)
     elif failure.check(errors.RemoteRunError):
         common.errorRaise(log.getFailureMessage(failure))
     else:
         common.errorRaise(log.getFailureMessage(failure))

	def _sendErrorAnswer(self, failure, qid):
		del self._theirQuestions[qid]
		if failure.check(KnownError):
			body = failure.value[0]
			self._sendQANFrame(KnownErrorAnswer(body, qid))
		elif failure.check(defer.CancelledError):
			self._sendQANFrame(UnknownErrorAnswer("CancelledError", qid))
		else:
			self._logError("Peer's Question #%d caused uncaught "
				"exception" % (qid,), failure)
			# We intentionally do not reveal information about the
			# exception.
			self._sendQANFrame(UnknownErrorAnswer("Uncaught exception", qid))

 def _error_handler(self, failure):
     if failure.check(tw_error.ConnectionRefusedError):
         self._on_disconnected()
         self.reconnect()
         raise NotConnectedError("Database connection refused.")
     elif (failure.check(httpclient.RequestError) and
           failure.value.cause and
           isinstance(failure.value.cause, tw_error.ConnectionDone)):
         self._on_disconnected()
         self.reconnect()
         raise NotConnectedError("Connection to the database was lost.")
     else:
         failure.raiseException()

    def on_failure(self, failure, request):
        """
        Handle exceptions raised during RestResource processing
        
        :param failure: ``twisted.python.failure.Failure`` instance
        :param request: ``twisted.web.server.Request`` instance
        """
        fq_name = self.__module__ + '.' + self.__class__.__name__
        file_path = abspath(inspect.getfile(self.__class__))

        if failure.check(CancelledError):
            # the request / deferred chain has been cancelled early.
            # doesn't matter if we respond no one is listening.
            rstr = err = 'Request was cancelled'
        elif failure.check(_DefGen_Return):
            failure.printBriefTraceback()
            err = dedent('''
                Received a Deferred Generator Response from Resource (%s)
                in the method:  [%s] ....................................
                This indicates you may be missing a yield statement and
                the decorator `@defer.inlineCallbacks`.
                File: %s
                
                If you do not have a yield statement, you should use a regular
                `return` statement and remove `defer.returnValue()`
            ''' % (fq_name, request.method_called, file_path)).strip()

            log.err(err + ' - ' + failure.getErrorMessage())
            rstr = self.ERROR_CLASS(
                INTERNAL_SERVER_ERROR,
                err,
                failure.getErrorMessage(),
                is_logged=False
            ).render(request)
        else:
            log.err('Exception in Resource (%s) [%s] <%s> - %s' % (
                fq_name, request.method_called, file_path, failure.getErrorMessage()))
            failure.printTraceback()
            rstr = self.ERROR_CLASS(
                INTERNAL_SERVER_ERROR,
                'Unhandled Error',
                'Exception in Resource (%s) [%s] <%s> - %s' % (
                    fq_name, request.method_called, file_path, failure.getTraceback()),
                is_logged=False
            ).render(request)

        if request.finished:
            return

        request.write(rstr)
        request.finish()

 def errback(failure):
     try:
         if failure.check(ServerMessage):
             self.root.runCallback('msg', failure.getErrorMessage())
         self.root._failure()
     finally:
         self._startCall()

 def _cbDeferRunCleanups(self, cleanupResults, result):
     for flag, failure in cleanupResults:
         if flag == defer.FAILURE:
             result.addError(self, failure)
             if failure.check(KeyboardInterrupt):
                 result.stop()
             self._passed = False

 def _eb(failure):
     if failure.check(*expectedFailures):
         return failure.value
     else:
         output = ('\nExpected: %r\nGot:\n%s'
                   % (expectedFailures, str(failure)))
         raise self.failureException(output)

 def _process(self, failure, data_cache, exceptions):
     for (exc, key, max_count, init_backoff,
          incr_backoff, max_backoff) in exceptions:
         if failure.check(*exc) is not None:
             count = data_cache.get(key, 0) + 1
             if max_count is not None and count >= max_count:
                 zc.async.utils.tracelog.warning(
                     'Retry policy for job %r is not retrying after %d '
                     'counts of %s occurrences', self.parent, count, key)
                 return False
             elif count==1 or not count % self.log_every:
                 zc.async.utils.tracelog.warning(
                     'Retry policy for job %r requests another attempt '
                     'after %d counts of %s occurrences', self.parent,
                     count, key, exc_info=True)
             backoff = min(max_backoff,
                           (init_backoff + (count-1) * incr_backoff))
             if backoff:
                 time.sleep(backoff)
             data_cache[key] = count
             data_cache['last_' + key] = failure
             if 'first_active' not in data_cache:
                 data_cache['first_active'] = self.parent.active_start
             return True
     return False

 def expected(self, failure):
     if self.errors is None:
         return True
     for error in self.errors:
         if failure.check(error):
             return True
     return False

 def _defaultErrback(self, failure, request):
     if failure.check(errors.UnknownComponentError,
             errors.NotAuthenticatedError) is None:
         # If something else went wrong, we want to disconnect the client
         # and give them a 500 Internal Server Error.
         self._handleUnauthorized(request, http.INTERNAL_SERVER_ERROR)
     return failure

def testSTORESmallFailed(failure, msg, node, nKu, host, port):
    if failure.check('flud.protocol.FludCommUtil.BadCASKeyException'):
        print "%s" % msg
        return testSTOREBadKeyLarge(nKu, node, host, port)
    else:
        print "\nSTORESmall expected BadCASKeyException," \
                " but got a different failure:"
        raise failure

        def matchException(failure):
            for errorState, backOff in self.backOffs.iteritems():
                if 'errorTypes' not in backOff:
                    continue
                if failure.check(*backOff['errorTypes']):
                    return errorState

            return 'other'

def testVERIFYBadKeyFailed(failure, msg, node, nKu, host, port):
    if failure.check('flud.protocol.FludCommUtil.NotFoundException'):
        print "%s" % msg
        return testDELETEBadKey(nKu, node, host, port)
    else:
        print "\nVERIFYBadKey expected NotFoundException," \
                " but got a different failure:"
        raise failure

def testRETRIEVENotFoundFailed(failure, msg, node, nKu, host, port):
    if failure.check('flud.protocol.FludCommUtil.NotFoundException'):
        print "%s" % msg
        return testRETRIEVEIllegalPath(nKu, node, host, port)
    else:
        print "\nRETRIEVENotFound expected NotFoundException," \
                " but got a different failure:"
        raise failure

def testVERIFYBadLengthFailed(failure, msg, node, nKu, host, port):
    if failure.check('flud.protocol.FludCommUtil.BadRequestException'):
        print "%s" % msg
        return testVERIFYBadKey(nKu, node, host, port)
    else:
        print "\nVERIFYBadLength expected BadRequestException," \
                " but got a different failure:"
        raise failure

 def errback(failure):
     if not self.currentlyAsking:
         return
     self.currentlyAsking = False
     if failure.check(ServerMessage):
         self.root.runCallback('msg', failure.getErrorMessage())
     self.root._failure()
     self._startCall()