def _on_discovery_timeout(self):
if self._done:
return
self._done = True
self.mcast.stopListening()
self._discovery.errback(
failure.Failure(defer.TimeoutError('in _on_discovery_timeout')))
def OnTimeout(self):
"""On a timeout condition, raise an error"""
if not self.finished:
self.finished = 1
self.result = defer.TimeoutError('SNMP request timed out')
self.success = 0
reactor.crash()
def _reissue(self, reason, addressesLeft, addressesUsed, query, timeout):
reason.trap(dns.DNSQueryTimeoutError)
# If there are no servers left to be tried, adjust the timeout
# to the next longest timeout period and move all the
# "used" addresses back to the list of addresses to try.
if not addressesLeft:
addressesLeft = addressesUsed
addressesLeft.reverse()
addressesUsed = []
timeout = timeout[1:]
# If all timeout values have been used this query has failed. Tell the
# protocol we're giving up on it and return a terminal timeout failure
# to our caller.
if not timeout:
return failure.Failure(defer.TimeoutError(query))
# Get an address to try. Take it out of the list of addresses
# to try and put it ino the list of already tried addresses.
address = addressesLeft.pop()
addressesUsed.append(address)
# Issue a query to a server. Use the current timeout. Add this
# function as a timeout errback in case another retry is required.
d = self._query(address, query, timeout[0], reason.value.id)
d.addErrback(self._reissue, addressesLeft, addressesUsed, query,
timeout)
return d
def convert_cancelled(value: failure.Failure):
# if the original deferred was cancelled, and our timeout has fired, then
# the reason it was cancelled was due to our timeout. Turn the CancelledError
# into a TimeoutError.
if timed_out[0] and value.check(CancelledError):
raise defer.TimeoutError("Timed out after %gs" % (timeout, ))
return value
def _wait(d, timeout=None, running=_wait_is_running):
from twisted.internet import reactor
if running:
raise WaitIsNotReentrantError, REENTRANT_WAIT_ERROR_MSG
results = []
def append(any):
if results is not None:
results.append(any)
def crash(ign):
if results is not None:
reactor.crash()
def stop():
reactor.crash()
running.append(None)
try:
d.addBoth(append)
if results:
return results[0]
d.addBoth(crash)
if timeout is None:
timeoutCall = None
else:
timeoutCall = reactor.callLater(timeout, reactor.crash)
reactor.stop = stop
try:
reactor.run()
finally:
del reactor.stop
if timeoutCall is not None:
if timeoutCall.active():
timeoutCall.cancel()
else:
f = failure.Failure(defer.TimeoutError('_wait timed out'))
return f
if results:
return results[0]
# If the timeout didn't happen, and we didn't get a result or
# a failure, then the user probably aborted the test, so let's
# just raise KeyboardInterrupt.
# FIXME: imagine this:
# web/test/test_webclient.py:
# exc = self.assertRaises(error.Error, unittest.wait, method(url))
#
# wait() will raise KeyboardInterrupt, and assertRaises will
# swallow it. Therefore, wait() raising KeyboardInterrupt is
# insufficient to stop trial. A suggested solution is to have
# this code set a "stop trial" flag, or otherwise notify trial
# that it should really try to stop as soon as possible.
raise KeyboardInterrupt()
finally:
results = None
running.pop()
def _timeout(self, key, df, oids, timeout, retryCount):
try:
try:
del self.protocol.requests[ key ]
except KeyError:
pass
if not df.called:
log.debug( 'timeout check %r', self )
if retryCount:
timeout *= 1.5
retryCount -= 1
log.debug( 'timeout retry %r %r %r', self, timeout, retryCount )
request = self.encode(oids, self.community)
key = self.getRequestKey( request )
try:
self.send(request.encode())
except socket.error, err:
df.errback( failure.Failure() )
return
else:
timer = reactor.callLater(
timeout,
self._timeout, key, df, oids, timeout, retryCount
)
self.protocol.requests[key] = df, timer
return
log.debug( """timeout raising error: %r""", self )
df.errback(defer.TimeoutError('SNMP request timed out'))
except Exception, err:
df.errback( failure.Failure() )
def __init__(self, message, cmdlist, matchFunc=None, timeout=10):
self.message = message
self.matchFunc = matchFunc or returner(True)
self._deferred = defer.Deferred()
terror = defer.TimeoutError("Message %s response timeout" % message.command)
self.timeoutCall = reactor.callLater(timeout, self.fail, terror)
self.cmdlist = cmdlist
def tableTimeout( self, df, key, oids, roots, includeStart, retryCount, delay ):
"""Table timeout implementation
Table queries timeout if a single retrieval
takes longer than retryCount * self.timeout
"""
if not df.called:
try:
if retryCount > 0:
try:
if self.proxy.protocol.requests[key][0] is df:
del self.proxy.protocol.requests[ key ]
except KeyError:
pass
return self.getTable( oids, roots, includeStart, retryCount-1, delay*1.5 )
try:
if not self.finished and getattr(self,'df',None):
self.df.errback( defer.TimeoutError('SNMP request timed out'))
del self.df
except defer.AlreadyCalledError:
pass
except Exception, err:
if getattr(self,'df',None) and not self.df.called:
self.df.errback( err )
del self.df
else:
log.warn(
"""Unhandled exception %r after request completed, ignoring: %s""",
log.getException(err),
)
def testFetchFailed(self):
testMessage = "Testing failed fetches"
testFailure = failure.Failure(defer.TimeoutError(testMessage))
self.monitor.checkStartTime = seconds()
with mock.patch.object(self.monitor, '_resultDown') as mock_resultDown:
self.monitor._fetchFailed(testFailure)
mock_resultDown.assert_called_once()
def timeoutConnection(self):
"""Called when the connection times out.
Will fail all pending requests with a TimeoutError.
"""
self.failRequests(defer.TimeoutError("Connection timeout"))
self.transport.loseConnection()
def test_ignores_timeouts_when_consuming_neighbour_event(self):
reverseResolve = self.patch(reverse_dns_module, "reverseResolve")
reverseResolve.return_value = defer.fail(defer.TimeoutError())
ip = factory.make_ip_address(ipv6=False)
service = ReverseDNSService()
yield callWithServiceRunning(service, service.consumeNeighbourEvent,
"create", "%s/32" % ip)
self.assertThat(reverseResolve, MockCalledOnceWith(ip))
result = yield deferToDatabase(RDNS.objects.first)
self.assertThat(result, Is(None))
def time_it_out():
timed_out[0] = True
try:
deferred.cancel()
except: # noqa: E722, if we throw any exception it'll break time outs
logger.exception("Canceller failed during timeout")
if not new_d.called:
new_d.errback(defer.TimeoutError(timeout, "Deferred"))
def _reissue(self, reason, address, query, timeout):
reason.trap(dns.DNSQueryTimeoutError)
timeout = timeout[1:]
if not timeout:
return failure.Failure(defer.TimeoutError(query))
d = self._query(address, query, timeout[0], reason.value.id)
d.addErrback(self._reissue, address, query, timeout)
return d
def timeout(self):
self.transport.loseConnection()
# transport cleanup needed for HTTPS connections
if self.factory.url.startswith(b'https'):
self.transport.stopProducing()
self.factory.noPage(
defer.TimeoutError(f"Getting {self.factory.url} took longer "
f"than {self.factory.timeout} seconds."))
def timeout(self):
self.transport.loseConnection()
# transport cleanup needed for HTTPS connections
if self.factory.url.startswith(b'https'):
self.transport.stopProducing()
self.factory.noPage(\
defer.TimeoutError("Getting %s took longer than %s seconds." % \
(self.factory.url, self.factory.timeout)))
def _timeout(self, calld, failure, timeout):
# calld is the deferred returned by __call__.
self._log.debug(
"Task timed out task-id=%s label=%s",
self.id,
self.label,
)
error = defer.TimeoutError("timeout")
calld.errback(error)
self.deferred.errback(error)
self._ontimeout = None
def _doTimeout(self, request):
"""
Give up the request because of a timeout.
:param request: The object defining the parameters of the request to
issue.
:type request: twisted.web._newclient.Request
"""
self._giveUp(
failure.Failure(
defer.TimeoutError("Getting %s took longer than %s seconds." %
(request.absoluteURI, self._timeout))))
def on_timeout(d):
e = defer.TimeoutError("(%s) still running at %s secs" % (method.__name__, timeout))
f = failure.Failure(e)
try:
d.errback(f)
except defer.AlreadyCalledError:
# if the deferred has been called already but the *back chain
# is still unfinished, crash the reactor and report timeout
# error ourself.
reactor.crash()
raise
def time_it_out():
timed_out[0] = True
try:
deferred.cancel()
except: # noqa: E722, if we throw any exception it'll break time outs
logger.exception("Canceller failed during timeout")
# the cancel() call should have set off a chain of errbacks which
# will have errbacked new_d, but in case it hasn't, errback it now.
if not new_d.called:
new_d.errback(defer.TimeoutError("Timed out after %gs" % (timeout,)))
def _check_and_wait(self, res=None):
self._check_timeout -= 1
if self._check_timeout <= 0:
raise defer.TimeoutError("gave up on command")
logs = self.collectUpdates()
if logs.get('stdout') == "this is stdout 0\nthis is stdout 1\n":
# the emitlogs.py process is now waiting for something to arrive
# on stdin
self.cmd.command.pp.transport.write("poke\n")
return
if not self.cmd.running:
self.fail("command finished too early")
spin = defer.Deferred()
spin.addCallback(self._check_and_wait)
reactor.callLater(1, spin.callback, None)
return spin
def substantiate(self, sb):
if self.substantiated:
self._clearBuildWaitTimer()
self._setBuildWaitTimer()
return defer.succeed(self)
if self.substantiation_deferred is None:
if self.parent and not self.missing_timer:
# start timer. if timer times out, fail deferred
self.missing_timer = reactor.callLater(
self.missing_timeout, self._substantiation_failed,
defer.TimeoutError())
self.substantiation_deferred = defer.Deferred()
if self.slave is None:
self._substantiate() # start up instance
# else: we're waiting for an old one to detach. the _substantiate
# will be done in ``detached`` below.
return self.substantiation_deferred
def testCheckFailure(self):
self.monitor.active = True
with mock.patch.multiple(self.monitor,
getProxyPage=mock.DEFAULT,
_fetchSuccessful=mock.DEFAULT,
_fetchFailed=mock.DEFAULT,
_checkFinished=mock.DEFAULT) as mocks:
mocks['getProxyPage'].return_value = defer.Deferred()
self.monitor.check()
# Check whether the callback works
testFailure = failure.Failure(defer.TimeoutError("Test failure"))
self.monitor.getPageDeferred.errback(testFailure)
mocks['_fetchFailed'].assert_called_once_with(testFailure)
mocks['_fetchSuccessful'].assert_not_called()
mocks['_checkFinished'].assert_called()
def substantiate(self, sb, build):
if self.substantiated:
self._clearBuildWaitTimer()
self._setBuildWaitTimer()
return defer.succeed(True)
if not self._substantiation_notifier:
if self.parent and not self.missing_timer:
# start timer. if timer times out, fail deferred
self.missing_timer = self.master.reactor.callLater(
self.missing_timeout,
self._substantiation_failed, defer.TimeoutError())
self.substantiation_build = build
if self.conn is None:
d = self._substantiate(build) # start up instance
d.addErrback(log.err, "while substantiating")
# else: we're waiting for an old one to detach. the _substantiate
# will be done in ``detached`` below.
return self._substantiation_notifier.wait()
def onTimeout(d):
e = defer.TimeoutError("%r (%s) still running at %s secs" %
(self, methodName, timeout))
f = failure.Failure(e)
# try to errback the deferred that the test returns (for no gorram
# reason) (see issue1005 and test_errorPropagation in test_deferred)
try:
d.errback(f)
except defer.AlreadyCalledError:
# if the deferred has been called already but the *back chain is
# still unfinished, crash the reactor and report timeout error
# ourself.
reactor.crash()
self._timedOut = True # see self._wait
todo = self.getTodo()
if todo is not None and todo.expected(f):
result.addExpectedFailure(self, f, todo)
else:
result.addError(self, f)
def substantiate(self, sb, build):
if self.substantiated:
self._clearBuildWaitTimer()
self._setBuildWaitTimer()
return defer.succeed(True)
if not self._substantiation_notifier:
if self.parent and not self.missing_timer:
# start timer. if timer times out, fail deferred
self.missing_timer = self.master.reactor.callLater(
self.missing_timeout, self._substantiation_failed,
defer.TimeoutError())
self.substantiation_build = build
# if substantiate fails synchronously we need to have the deferred ready to be notified
d = self._substantiation_notifier.wait()
if self.conn is None:
self._substantiate(build)
# else: we're waiting for an old one to detach. the _substantiate
# will be done in ``detached`` below.
return d
return self._substantiation_notifier.wait()
def _timeout(self, reason, query):
reason.trap(dns.DNSQueryTimeoutError)
log.msg('Timeout for %r' % query)
log.msg('Given up')
return failure.Failure(defer.TimeoutError(query))
def _cancelled_to_timed_out_error(value, timeout):
if isinstance(value, failure.Failure):
value.trap(CancelledError)
raise defer.TimeoutError(timeout, "Deferred")
return value
def _missing_timer_fired(self):
self.missing_timer = None
return self._substantiation_failed(defer.TimeoutError())
def do_timeout():
df.errback(failure.Failure(defer.TimeoutError('in Event.get_deferred')))
once.unwatch(id1)
once.unwatch(x)
def timeout(self):
self.transport.loseConnection()
self.factory.noPage(\
defer.TimeoutError("Getting %s took longer than %s seconds." % \
(self.factory.url, self.factory.timeout)))
