def handle_loop_error(err: Failure, loop_handler: LoopHandler) -> None:
"""Handle errors in a looping function and restart the loop."""
send_problem_report(err)
err.printTraceback()
# Sleep to avoid tight infinite loops spamming emails
time.sleep(3)
# Restart the given method
loop_handler.start_loop()
def handle(self, message, address):
try:
(v, ) = message.arguments
self.dispatch(self._transform(float(v)))
except Exception, e:
f = Failure(e)
f.printTraceback()
log.msg('[FloatDispatcher.handle] error', e)
def dispatch(self, *a, **k):
for handler in self._listeners:
try:
handler(*a, **k)
except Exception, e:
f = Failure(e)
f.printTraceback()
log.err(e)
def __init__(self, *args, **kwargs):
try:
raise RuntimeError()
except RuntimeError:
from twisted.python.failure import Failure
f = Failure()
f.printTraceback()
return super(ReportingProtocolWrapper, self).__init__(*args, **kwargs)
def dispatch(self, *a, **k):
for handler in self._listeners:
try:
handler(*a, **k)
except Exception, e:
f = Failure(e)
f.printTraceback()
log.err(e)
def handle(self, message, address):
try:
(v,) = message.arguments
self.dispatch(self._transform(float(v)))
except Exception, e:
f = Failure(e)
f.printTraceback()
log.msg('[FloatDispatcher.handle] error', e)
def fail(failure: Failure) -> None:
# If the Deferred was cancelled (e.g. during shutdown) do not try to
# reconnect (this will cause an infinite loop of errors).
if failure.check(CancelledError) and self._stopping:
return
# For a different error, print the traceback and re-connect.
failure.printTraceback(file=sys.__stderr__)
self._connection_waiter = None
self._connect()
def write(self, data):
"""write data to some file like object only writes happen if debug was
specified during instantiation.
"""
if hasattr(self.fd, 'write') and hasattr(self.fd.write, '__call__') \
and self.debug: #only write on debug true
try:
self.fd.write(str(data)+'\n')
except:
failure = Failure()
if self.verbose: failure.printDetailedTraceback(sys.stderr)
else: failure.printTraceback(sys.stderr)
def write(self, data):
"""write data to some file like object only writes happen if debug was
specified during instantiation.
"""
if hasattr(self.fd, 'write') and hasattr(self.fd.write, '__call__') \
and self.debug: #only write on debug true
try:
self.fd.write(str(data) + '\n')
except:
failure = Failure()
if self.verbose: failure.printDetailedTraceback(sys.stderr)
else: failure.printTraceback(sys.stderr)
def callRemote(self, name, *args, **kw):
"""Call a specially-designated local method.
self.callRemote('x') will first try to invoke a method named
sync_x and return its result (which should probably be a
Deferred). Second, it will look for a method called async_x,
which will be called and then have its result (or Failure)
automatically wrapped in a Deferred.
"""
if hasattr(self, 'sync_'+name):
return getattr(self, 'sync_'+name)(*args, **kw)
try:
method = getattr(self, "async_" + name)
return defer.succeed(method(*args, **kw))
except:
f = Failure()
if self.reportAllTracebacks:
f.printTraceback()
return defer.fail(f)
def display_result(self, result):
"""display the result in debug mode, always display tracebacks
on failure. this is callback safe.
@param result (object)
@return (param -> result)
"""
if isinstance(result, Failure):
if hasattr(result.value, "__class__"):
eName = result.value.__class__.__name__
else: # guess in event failure doesn't make sense
try: # preload and reset later
eName = sys.exc_info()[0].__name__
except AttributeError:
eName = "Unknown" # fail
except:
failure = Failure()
self.write("Something bad has happened")
fd = self.fd
if not fd:
self.fd = sys.stderr
if self.verbose:
failure.printDetailedTraceback(self.fd)
else:
failure.printTraceback(self.fd)
# restore the previous fd object
self.fd = fd
return result
self.write(">>> %s call raised %s" % (self.function.func_name, eName))
# make sure the fd is valid for tracebacks
fd = self.fd
if not fd:
self.fd = sys.stderr
if self.verbose:
result.printDetailedTraceback(self.fd)
else:
result.printTraceback(self.fd)
# restore the previous fd object
self.fd = fd
self.write(">>>")
else:
self.write(">>> Returning %s -> %s" % (self.function.func_name, str(result)))
return result
def callRemote(self, name, *args, **kw):
"""Call a specially-designated local method.
self.callRemote('x') will first try to invoke a method named
sync_x and return its result (which should probably be a
Deferred). Second, it will look for a method called async_x,
which will be called and then have its result (or Failure)
automatically wrapped in a Deferred.
"""
if hasattr(self, 'sync_' + name):
return getattr(self, 'sync_' + name)(*args, **kw)
try:
method = getattr(self, "async_" + name)
return defer.succeed(method(*args, **kw))
except:
f = Failure()
if self.reportAllTracebacks:
f.printTraceback()
return defer.fail(f)
def display_result(self, result):
"""display the result in debug mode, always display tracebacks
on failure. this is callback safe.
@param result (object)
@return (param -> result)
"""
if isinstance(result, Failure):
if hasattr(result.value, '__class__'):
eName = result.value.__class__.__name__
else: #guess in event failure doesn't make sense
try: #preload and reset later
eName = sys.exc_info()[0].__name__
except AttributeError:
eName = 'Unknown' #fail
except:
failure = Failure()
self.write('Something bad has happened')
fd = self.fd
if not fd: self.fd = sys.stderr
if self.verbose: failure.printDetailedTraceback(self.fd)
else: failure.printTraceback(self.fd)
#restore the previous fd object
self.fd = fd
return result
self.write(">>> %s call raised %s" % \
(self.function.func_name, eName))
#make sure the fd is valid for tracebacks
fd = self.fd
if not fd: self.fd = sys.stderr
if self.verbose: result.printDetailedTraceback(self.fd)
else: result.printTraceback(self.fd)
#restore the previous fd object
self.fd = fd
self.write(">>>")
else:
self.write(">>> Returning %s -> %s" % \
(self.function.func_name,str(result)))
return result
def run(self):
"""
Function that does common PUT/COPY/MOVE behavior.
@return: a Deferred with a status response result.
"""
try:
reservation = None
# Handle all validation operations here.
yield self.fullValidation()
# Reservation and UID conflict checking is next.
if self.destinationadbk:
# Reserve UID
self.destination_index = self.destinationparent.index()
reservation = StoreAddressObjectResource.UIDReservation(
self.destination_index, self.uid, self.destination_uri
)
if self.indexdestination:
yield reservation.reserve()
# UID conflict check - note we do this after reserving the UID to avoid a race condition where two requests
# try to write the same vcard data to two different resource URIs.
result, message, rname = self.noUIDConflict(self.uid)
if not result:
log.err(message)
raise HTTPError(ErrorResponse(responsecode.FORBIDDEN,
NoUIDConflict(davxml.HRef.fromString(joinURL(parentForURL(self.destination_uri), rname.encode("utf-8"))))
))
# Get current quota state.
yield self.checkQuota()
# Do the actual put or copy
response = (yield self.doStore())
# Remember the resource's content-type.
if self.destinationadbk:
content_type = self.request.headers.getHeader("content-type")
if content_type is None:
content_type = MimeType("text", "vcard",
params={"charset":"utf-8"})
self.destination.writeDeadProperty(
davxml.GETContentType.fromString(generateContentType(content_type))
)
# Delete the original source if needed.
if self.deletesource:
yield self.doSourceQuotaCheck()
# Do quota check on destination
if self.destquota is not None:
yield self.doDestinationQuotaCheck()
if reservation:
yield reservation.unreserve()
returnValue(response)
except Exception, err:
# Preserve the real traceback to display later, since the error-
# handling here yields out of the generator and thereby shreds the
# stack.
f = Failure()
if reservation:
yield reservation.unreserve()
# FIXME: transaction needs to be rolled back.
# Display the traceback. Unfortunately this will usually be
# duplicated by the higher-level exception handler that captures
# the thing that raises here, but it's better than losing the
# information.
f.printTraceback()
raise err
