def maybeDeferred(f, *args, **kw):
"""Invoke a function that may or may not return a deferred.
Call the given function with the given arguments. If the returned
object is a C{Deferred}, return it. If the returned object is a C{Failure},
wrap it with C{fail} and return it. Otherwise, wrap it in C{succeed} and
return it. If an exception is raised, convert it to a C{Failure}, wrap it
in C{fail}, and then return it.
@type f: Any callable
@param f: The callable to invoke
@param args: The arguments to pass to C{f}
@param kw: The keyword arguments to pass to C{f}
@rtype: C{Deferred}
@return: The result of the function call, wrapped in a C{Deferred} if
necessary.
"""
try:
result = f(*args, **kw)
except:
return fail(Failure())
if isinstance(result, Deferred):
return result
elif isinstance(result, Failure):
return fail(result)
else:
return succeed(result)
def _runCallbacks(self):
if self._runningCallbacks:
# Don't recursively run callbacks
return
if not self.paused:
while self.callbacks:
item = self.callbacks.pop(0)
callback, args, kw = item[
isinstance(self.result, Failure)]
args = args or ()
kw = kw or {}
try:
self._runningCallbacks = True
try:
self.result = callback(self.result, *args, **kw)
finally:
self._runningCallbacks = False
if isinstance(self.result, Deferred):
# note: this will cause _runCallbacks to be called
# recursively if self.result already has a result.
# This shouldn't cause any problems, since there is no
# relevant state in this stack frame at this point.
# The recursive call will continue to process
# self.callbacks until it is empty, then return here,
# where there is no more work to be done, so this call
# will return as well.
self.pause()
self.result.addBoth(self._continue)
break
except:
self.result = Failure()
if isinstance(self.result, Failure):
self.result.cleanFailure()
if self._debugInfo is None:
self._debugInfo = DebugInfo()
self._debugInfo.failResult = self.result
else:
if self._debugInfo is not None:
self._debugInfo.failResult = None
def _cbDeferred(self, result, index, succeeded):
"""(internal) Callback for when one of my deferreds fires.
"""
self.resultList[index] = (succeeded, result)
self.finishedCount += 1
if not self.called:
if succeeded == SUCCESS and self.fireOnOneCallback:
self.callback((result, index))
elif succeeded == FAILURE and self.fireOnOneErrback:
self.errback(Failure(FirstError(result, index)))
elif self.finishedCount == len(self.resultList):
self.callback(self.resultList)
if succeeded == FAILURE and self.consumeErrors:
result = None
return result
def errback(self, fail=None):
"""
Run all error callbacks that have been added to this 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 Exception, processing will continue on the
*success*-callback chain.
If the argument that's passed to me is not a Failure instance,
it will be embedded in one. If no argument is passed, a 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.
@raise NoCurrentExceptionError: If C{fail} is C{None} but there is
no current exception state.
"""
if not isinstance(fail, Failure):
fail = Failure(fail)
self._startRunCallbacks(fail)
class Deferred:
"""This is a callback which will be put off until later.
Why do we want this? Well, in cases where a function in a threaded
program would block until it gets a result, for Twisted it should
not block. Instead, it should return a Deferred.
This can be implemented for protocols that run over the network by
writing an asynchronous protocol for twisted.internet. For methods
that come from outside packages that are not under our control, we use
threads (see for example L{twisted.enterprise.adbapi}).
For more information about Deferreds, see doc/howto/defer.html or
U{http://twistedmatrix.com/projects/core/documentation/howto/defer.html}
"""
called = 0
paused = 0
timeoutCall = None
_debugInfo = None
# Are we currently running a user-installed callback? Meant to prevent
# recursive running of callbacks when a reentrant call to add a callback is
# used.
_runningCallbacks = False
# Keep this class attribute for now, for compatibility with code that
# sets it directly.
debug = False
def __init__(self):
self.callbacks = []
if self.debug:
self._debugInfo = DebugInfo()
self._debugInfo.creator = traceback.format_stack()[:-1]
def addCallbacks(
self, callback, errback=None, callbackArgs=None, callbackKeywords=None, errbackArgs=None, errbackKeywords=None
):
"""Add a pair of callbacks (success and error) to this Deferred.
These will be executed when the 'master' callback is run.
"""
assert callable(callback)
assert errback == None or callable(errback)
cbs = ((callback, callbackArgs, callbackKeywords), (errback or (passthru), errbackArgs, errbackKeywords))
self.callbacks.append(cbs)
if self.called:
self._runCallbacks()
return self
def addCallback(self, callback, *args, **kw):
"""Convenience method for adding just a callback.
See L{addCallbacks}.
"""
return self.addCallbacks(callback, callbackArgs=args, callbackKeywords=kw)
def addErrback(self, errback, *args, **kw):
"""Convenience method for adding just an errback.
See L{addCallbacks}.
"""
return self.addCallbacks(passthru, errback, errbackArgs=args, errbackKeywords=kw)
def addBoth(self, callback, *args, **kw):
"""Convenience method for adding a single callable as both a callback
and an errback.
See L{addCallbacks}.
"""
return self.addCallbacks(
callback, callback, callbackArgs=args, errbackArgs=args, callbackKeywords=kw, errbackKeywords=kw
)
def chainDeferred(self, d):
"""Chain another Deferred to this Deferred.
This method adds callbacks to this Deferred to call d's callback or
errback, as appropriate. It is merely a shorthand way of performing
the following::
self.addCallbacks(d.callback, d.errback)
When you chain a deferred d2 to another deferred d1 with
d1.chainDeferred(d2), you are making d2 participate in the callback
chain of d1. Thus any event that fires d1 will also fire d2.
However, the converse is B{not} true; if d2 is fired d1 will not be
affected.
"""
return self.addCallbacks(d.callback, d.errback)
def callback(self, result):
"""Run all success callbacks that have been added to this 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 success-callback returns a Failure
or raises an Exception, processing will continue on the *error*-
callback chain.
"""
assert not isinstance(result, Deferred)
self._startRunCallbacks(result)
def errback(self, fail=None):
"""
Run all error callbacks that have been added to this 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 Exception, processing will continue on the
*success*-callback chain.
If the argument that's passed to me is not a Failure instance,
it will be embedded in one. If no argument is passed, a 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.
@raise NoCurrentExceptionError: If C{fail} is C{None} but there is
no current exception state.
"""
if not isinstance(fail, Failure):
fail = Failure(fail)
self._startRunCallbacks(fail)
def pause(self):
"""Stop processing on a Deferred until L{unpause}() is called.
"""
self.paused = self.paused + 1
def unpause(self):
"""Process all callbacks made since L{pause}() was called.
"""
self.paused = self.paused - 1
if self.paused:
return
if self.called:
self._runCallbacks()
def _continue(self, result):
self.result = result
self.unpause()
def _startRunCallbacks(self, result):
if self.called:
if self.debug:
if self._debugInfo is None:
self._debugInfo = DebugInfo()
extra = "\n" + self._debugInfo._getDebugTracebacks()
raise AlreadyCalledError(extra)
raise AlreadyCalledError
if self.debug:
if self._debugInfo is None:
self._debugInfo = DebugInfo()
self._debugInfo.invoker = traceback.format_stack()[:-2]
self.called = True
self.result = result
if self.timeoutCall:
try:
self.timeoutCall.cancel()
except:
pass
del self.timeoutCall
self._runCallbacks()
def _runCallbacks(self):
if self._runningCallbacks:
# Don't recursively run callbacks
return
if not self.paused:
while self.callbacks:
item = self.callbacks.pop(0)
callback, args, kw = item[isinstance(self.result, Failure)]
args = args or ()
kw = kw or {}
try:
self._runningCallbacks = True
try:
self.result = callback(self.result, *args, **kw)
finally:
self._runningCallbacks = False
if isinstance(self.result, Deferred):
# note: this will cause _runCallbacks to be called
# recursively if self.result already has a result.
# This shouldn't cause any problems, since there is no
# relevant state in this stack frame at this point.
# The recursive call will continue to process
# self.callbacks until it is empty, then return here,
# where there is no more work to be done, so this call
# will return as well.
self.pause()
self.result.addBoth(self._continue)
break
except:
self.result = Failure()
if isinstance(self.result, Failure):
self.result.cleanFailure()
if self._debugInfo is None:
self._debugInfo = DebugInfo()
self._debugInfo.failResult = self.result
else:
if self._debugInfo is not None:
self._debugInfo.failResult = None
def __str__(self):
cname = self.__class__.__name__
if hasattr(self, "result"):
return "<%s at %s current result: %r>" % (cname, hex(unsignedID(self)), self.result)
return "<%s at %s>" % (cname, hex(unsignedID(self)))
__repr__ = __str__
class Deferred:
"""This is a callback which will be put off until later.
Why do we want this? Well, in cases where a function in a threaded
program would block until it gets a result, for Twisted it should
not block. Instead, it should return a Deferred.
This can be implemented for protocols that run over the network by
writing an asynchronous protocol for twisted.internet. For methods
that come from outside packages that are not under our control, we use
threads (see for example L{twisted.enterprise.adbapi}).
For more information about Deferreds, see doc/howto/defer.html or
U{http://twistedmatrix.com/projects/core/documentation/howto/defer.html}
"""
called = 0
paused = 0
timeoutCall = None
_debugInfo = None
# Are we currently running a user-installed callback? Meant to prevent
# recursive running of callbacks when a reentrant call to add a callback is
# used.
_runningCallbacks = False
# Keep this class attribute for now, for compatibility with code that
# sets it directly.
debug = False
def __init__(self):
self.callbacks = []
if self.debug:
self._debugInfo = DebugInfo()
self._debugInfo.creator = traceback.format_stack()[:-1]
def addCallbacks(self, callback, errback=None,
callbackArgs=None, callbackKeywords=None,
errbackArgs=None, errbackKeywords=None):
"""Add a pair of callbacks (success and error) to this Deferred.
These will be executed when the 'master' callback is run.
"""
assert hasattr(callback, '__call__')
assert errback == None or hasattr(errback,'__call__')
cbs = ((callback, callbackArgs, callbackKeywords),
(errback or (passthru), errbackArgs, errbackKeywords))
self.callbacks.append(cbs)
if self.called:
self._runCallbacks()
return self
def addCallback(self, callback, *args, **kw):
"""Convenience method for adding just a callback.
See L{addCallbacks}.
"""
return self.addCallbacks(callback, callbackArgs=args,
callbackKeywords=kw)
def addErrback(self, errback, *args, **kw):
"""Convenience method for adding just an errback.
See L{addCallbacks}.
"""
return self.addCallbacks(passthru, errback,
errbackArgs=args,
errbackKeywords=kw)
def addBoth(self, callback, *args, **kw):
"""Convenience method for adding a single callable as both a callback
and an errback.
See L{addCallbacks}.
"""
return self.addCallbacks(callback, callback,
callbackArgs=args, errbackArgs=args,
callbackKeywords=kw, errbackKeywords=kw)
def chainDeferred(self, d):
"""Chain another Deferred to this Deferred.
This method adds callbacks to this Deferred to call d's callback or
errback, as appropriate. It is merely a shorthand way of performing
the following::
self.addCallbacks(d.callback, d.errback)
When you chain a deferred d2 to another deferred d1 with
d1.chainDeferred(d2), you are making d2 participate in the callback
chain of d1. Thus any event that fires d1 will also fire d2.
However, the converse is B{not} true; if d2 is fired d1 will not be
affected.
"""
return self.addCallbacks(d.callback, d.errback)
def callback(self, result):
"""Run all success callbacks that have been added to this 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 success-callback returns a Failure
or raises an Exception, processing will continue on the *error*-
callback chain.
"""
assert not isinstance(result, Deferred)
self._startRunCallbacks(result)
def errback(self, fail=None):
"""
Run all error callbacks that have been added to this 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 Exception, processing will continue on the
*success*-callback chain.
If the argument that's passed to me is not a Failure instance,
it will be embedded in one. If no argument is passed, a 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.
@raise NoCurrentExceptionError: If C{fail} is C{None} but there is
no current exception state.
"""
if not isinstance(fail, Failure):
fail = Failure(fail)
self._startRunCallbacks(fail)
def pause(self):
"""Stop processing on a Deferred until L{unpause}() is called.
"""
self.paused = self.paused + 1
def unpause(self):
"""Process all callbacks made since L{pause}() was called.
"""
self.paused = self.paused - 1
if self.paused:
return
if self.called:
self._runCallbacks()
def _continue(self, result):
self.result = result
self.unpause()
def _startRunCallbacks(self, result):
if self.called:
if self.debug:
if self._debugInfo is None:
self._debugInfo = DebugInfo()
extra = "\n" + self._debugInfo._getDebugTracebacks()
raise AlreadyCalledError(extra)
raise AlreadyCalledError
if self.debug:
if self._debugInfo is None:
self._debugInfo = DebugInfo()
self._debugInfo.invoker = traceback.format_stack()[:-2]
self.called = True
self.result = result
if self.timeoutCall:
try:
self.timeoutCall.cancel()
except:
pass
del self.timeoutCall
self._runCallbacks()
def _runCallbacks(self):
if self._runningCallbacks:
# Don't recursively run callbacks
return
if not self.paused:
while self.callbacks:
item = self.callbacks.pop(0)
callback, args, kw = item[
isinstance(self.result, Failure)]
args = args or ()
kw = kw or {}
try:
self._runningCallbacks = True
try:
self.result = callback(self.result, *args, **kw)
finally:
self._runningCallbacks = False
if isinstance(self.result, Deferred):
# note: this will cause _runCallbacks to be called
# recursively if self.result already has a result.
# This shouldn't cause any problems, since there is no
# relevant state in this stack frame at this point.
# The recursive call will continue to process
# self.callbacks until it is empty, then return here,
# where there is no more work to be done, so this call
# will return as well.
self.pause()
self.result.addBoth(self._continue)
break
except:
self.result = Failure()
if isinstance(self.result, Failure):
self.result.cleanFailure()
if self._debugInfo is None:
self._debugInfo = DebugInfo()
self._debugInfo.failResult = self.result
else:
if self._debugInfo is not None:
self._debugInfo.failResult = None
def __str__(self):
cname = self.__class__.__name__
if hasattr(self, 'result'):
return "<%s at %s current result: %r>" % (cname, hex(unsignedID(self)),
self.result)
return "<%s at %s>" % (cname, hex(unsignedID(self)))
__repr__ = __str__
def timeout(deferred):
deferred.errback(Failure(TimeoutError("Callback timed out")))
