'Run all error callbacks that have been added to this L{Deferred}.
Each callback will have its result passed as the first
argument to the next; this way, the callbacks act as a
\'processing chain\'. Also, if the error-callback returns a non-Failure
or doesn\'t raise an L{Exception}, processing will continue on the
*success*-callback chain.
If the argument that\'s passed to me is not a L{failure.Failure} instance,
it will be embedded in one. If no argument is passed, a
L{failure.Failure} instance will be created based on the current
traceback stack.
Passing a string as `fail\' is deprecated, and will be punished with
a warning message.
An instance of L{Deferred} may only have either L{callback} or
L{errback} called on it, and only once.
@param fail: The L{Failure} object which will be passed to the first
errback added to this L{Deferred} (via L{addErrback}).
Alternatively, a L{Exception} instance from which a L{Failure} will
be constructed (with no traceback) or L{None} to create a L{Failure}
instance from the current exception state (with a traceback).
@raise AlreadyCalledError: If L{callback} or L{errback} has already been
called on this L{Deferred}.
@raise NoCurrentExceptionError: If C{fail} is L{None} but there is
no current exception state.'

def errback(self, fail=None):

    if (fail is None):
        fail = failure.Failure(captureVars=self.debug)
    elif (not isinstance(fail, failure.Failure)):
        fail = failure.Failure(fail)
    self._startRunCallbacks(fail)
