def timeoutConnection(self):
"""
Close the connection in case of timeout.
"""
for cmd in self._current:
cmd.fail(TimeoutError("Connection timeout"))
self.transport.loseConnection()
def test_remove_security_groups_raises_http_timeout(self):
"""Verify that a timeout in txaws raises an appropiate error.
This is an example of a scenario where txaws may not raise an
EC2Error, but will instead raise some other error.
"""
system_state = MockInstanceState(self, ["i-amkillable"], [0],
[["shutting-down"], ["shutting-down"],
["shutting-down"], ["terminated"]])
self.ec2.describe_instances("i-amkillable")
self.mocker.call(system_state.get_round)
self.mocker.count(4)
self.ec2.delete_security_group("juju-moon-0")
self.mocker.result(
fail(
TimeoutError(
"Getting https://x.example.com?Action=DeleteSecurityGroup"
"&etc=andsoforth took longer than 30 seconds.")))
self.mocker.replay()
provider = self.get_provider()
ex = yield self.assertFailure(
remove_security_groups(provider, ["i-amkillable"]), TimeoutError)
self.assertEquals(
str(ex), "Getting https://x.example.com?Action=DeleteSecurityGroup"
"&etc=andsoforth took longer than 30 seconds.")
def runReactor(self, reactor, timeout=None):
"""
Run the reactor for at most the given amount of time.
@param reactor: The reactor to run.
@type timeout: C{int} or C{float}
@param timeout: The maximum amount of time, specified in seconds, to
allow the reactor to run. If the reactor is still running after
this much time has elapsed, it will be stopped and an exception
raised. If C{None}, the default test method timeout imposed by
Trial will be used. This depends on the L{IReactorTime}
implementation of C{reactor} for correct operation.
@raise TimeoutError: If the reactor is still running after C{timeout}
seconds.
"""
if timeout is None:
timeout = self.getTimeout()
timedOut = []
def stop():
timedOut.append(None)
reactor.stop()
reactor.callLater(timeout, stop)
reactor.run()
if timedOut:
raise TimeoutError(
"reactor still running after %s seconds" % (timeout,))
def test_continuesWhenAllRootHintsFail(self):
"""
The L{root.Resolver} is eventually created, even if all of the root hint
lookups fail. Pending and new lookups will then fail with
AttributeError.
"""
stubResolver = StubResolver()
deferredResolver = root.bootstrap(stubResolver)
results = iter(stubResolver.pendingResults)
d1 = next(results)
for d in results:
d.errback(TimeoutError())
d1.errback(TimeoutError())
def checkHints(res):
self.assertEqual(deferredResolver.hints, [])
d1.addBoth(checkHints)
self.addCleanup(self.flushLoggedErrors, TimeoutError)
def sync_wait(deferred, timeout=10):
if not isinstance(deferred, Deferred):
return deferred
queue = Queue()
deferred.addBoth(queue.put)
try:
result = queue.get(True, timeout)
except Empty:
raise TimeoutError("Command timed out")
if isinstance(result, Failure):
result.raiseException()
return result
def _request_timeout(self, tx_tid):
self.log.debug("_request_timeout", tx_tid=tx_tid)
if tx_tid in self._requests:
req = self._requests[
tx_tid] # (0: timestamp, 1: defer, 2: frame, 3: timeout, 4: retry, 5: delayedCall)
frame = req[2]
timeout = req[3]
retry = req[4]
if retry > 0:
retry -= 1
self.send(frame, timeout, retry)
else:
d = req[1]
d.errback(
failure.Failure(
TimeoutError(timeout,
"Send OMCI TID -{}".format(tx_tid))))
def test_continuesWhenSomeRootHintsFail(self):
"""
The L{root.Resolver} is eventually created, even if some of the root
hint lookups fail. Only the working root hint IP addresses are supplied
to the L{root.Resolver}.
"""
stubResolver = StubResolver()
deferredResolver = root.bootstrap(stubResolver)
results = iter(stubResolver.pendingResults)
d1 = next(results)
for d in results:
d.callback('192.0.2.101')
d1.errback(TimeoutError())
def checkHints(res):
self.assertEqual(deferredResolver.hints, ['192.0.2.101'] * 12)
d1.addBoth(checkHints)
def _request_failure(self, value, tx_tid, high_priority):
"""
Handle a transmit failure. Rx Timeouts are handled on the 'dc' deferred and
will call a different method that may retry if requested. This routine
will be called after the final (if any) timeout or other error
:param value: (Failure) Twisted failure
:param tx_tid: (int) Associated Tx TID
"""
index = self._get_priority_index(high_priority)
if self._tx_request[index] is not None:
tx_frame = self._tx_request[index][OMCI_CC.REQUEST_FRAME]
tx_frame_tid = tx_frame.fields['transaction_id']
if tx_frame_tid == tx_tid:
timeout = self._tx_request[index][OMCI_CC.REQUEST_TIMEOUT]
dc = self._tx_request[index][OMCI_CC.REQUEST_DELAYED_CALL]
self._tx_request[index] = None
if dc is not None and not dc.called and not dc.cancelled:
dc.cancel()
if isinstance(value, failure.Failure):
value.trap(CancelledError)
self._rx_timeouts += 1
self._consecutive_errors += 1
if self._consecutive_errors == 1:
reactor.callLater(0, self._publish_connectivity_event,
False)
self.log.debug('timeout', tx_id=tx_tid, timeout=timeout)
value = failure.Failure(TimeoutError(timeout, "Deferred"))
else:
# Search pending queue. This may be a cancel coming in from the original
# task that requested the Tx. If found, remove
# from pending queue
for index, request in enumerate(self._pending[index]):
req = request.get(OMCI_CC.PENDING_DEFERRED)
if req is not None and req.fields[
'transaction_id'] == tx_tid:
self._pending[index].pop(index)
break
self._send_next_request(high_priority)
return value
def _request_timeout(self, tx_tid, high_priority):
"""
Tx Request timed out. Resend immediately if there retries is non-zero. A
separate deferred (dc) is used on each actual Tx which is not the deferred
(d) that is returned to the caller of the 'send()' method.
If the timeout if the transmitted frame was zero, this is just cleanup of
that transmit request and not necessarily a transmit timeout
:param tx_tid: (int) TID of frame
:param high_priority: (bool) True if high-priority queue
"""
self.log.debug("_request_timeout", tx_tid=tx_tid)
index = self._get_priority_index(high_priority)
if self._tx_request[index] is not None:
# (0: timestamp, 1: defer, 2: frame, 3: timeout, 4: retry, 5: delayedCall)
ts, d, frame, timeout, retry, _dc = self._tx_request[index]
if frame.fields.get('transaction_id', 0) == tx_tid:
self._tx_request[index] = None
if timeout > 0:
self._rx_timeouts += 1
if retry > 0:
# Push on front of TX pending queue so that it transmits next with the
# original TID
self._queue_frame(d,
frame,
timeout,
retry - 1,
high_priority,
front=True)
elif not d.called:
d.errback(
failure.Failure(
TimeoutError(
timeout,
"Send OMCI TID -{}".format(tx_tid))))
else:
self.log.warn('timeout-but-not-the-tx-frame'
) # Statement mainly for debugging
self._send_next_request(high_priority)
def failure(self, error):
if error and hasattr(error, "value"):
if issubclass(type(error.value), ConnectError):
log_msg("Bank appears to be down?")
error = None
elif issubclass(type(error.value), TimeoutError):
log_msg("Payment was dropped, trying again...", 4, "par")
error = None
if error:
log_ex(error, "Bank payment message failed!")
#check if the global timeout is up yet:
if time.time() < self.doneTime:
#and if not, send try sending again
self.proxy_message()
#otherwise, trigger the errback
else:
self.finishedDeferred.errback(TimeoutError())
def _request_failure(self, value, tx_tid):
"""
Handle a transmit failure and/or Rx timeout
:param value: (Failure) Twisted failure
:param tx_tid: (int) Associated Tx TID
"""
if tx_tid in self._requests:
(_, _, _, timeout) = self._requests.pop(tx_tid)
else:
timeout = 0
if isinstance(value, failure.Failure):
value.trap(CancelledError)
self._rx_timeouts += 1
self._consecutive_errors += 1
self.log.info('timeout', tx_id=tx_tid, timeout=timeout)
value = failure.Failure(TimeoutError(timeout, "Deferred"))
return value
def _request_failure(self, value, tx_tid):
"""
Handle a transmit failure and/or Rx timeout
:param value: (Failure) Twisted failure
:param tx_tid: (int) Associated Tx TID
"""
if tx_tid in self._requests:
(_, _, _, timeout, retry, dc) = self._requests.pop(tx_tid)
if dc is not None and not dc.called and not dc.cancelled:
dc.cancel()
if isinstance(value, failure.Failure):
value.trap(CancelledError)
self._rx_timeouts += 1
self._consecutive_errors += 1
if self._consecutive_errors == 1:
reactor.callLater(0, self._publish_connectivity_event, False)
self.log.info('timeout', tx_id=tx_tid, timeout=timeout)
value = failure.Failure(TimeoutError(timeout, "Deferred"))
return value
def _ack_timed_out(tm, cache_request):
lg.out(_DebugLevel, "propagate.PingContact._ack_timed_out")
if not cache_request.called:
cache_request.cancel()
ping_result.errback(
TimeoutError('response was not received within %d seconds' % tm))
def __init__(self, id):
TimeoutError.__init__(self)
self.id = id
def to():
if not already_fired[0]:
already_fired[0] = True
wrapper_d.errback(
TimeoutError("More than %i seconds elapsed" % timeout))
def __init__(self, id):
TimeoutError.__init__(self)
self.id = id
def timed_out(self):
if not self.done:
self.done = True
self.listener.stopListening()
self.finishedDeferred.errback(TimeoutError())
def _schedule_timeout(self, result=None):
Scheduler.schedule_once(self.timeout, self.failure, TimeoutError())
def _response_timed_out(pkt_out):
lg.out(_DebugLevel,
"propagate.PingContact._response_timed_out : %s" % pkt_out)
if not ping_result.called:
ping_result.errback(TimeoutError('remote user did not responded'))
return None
def got_timeout(self, e):
for u in self.users:
u.errback(TimeoutError())
self.users = []
self.stop_tasks()
def timeoutConnection(self):
"""
Close the connection in case of timeout.
"""
self._cancelCommands(TimeoutError("Connection timeout"))
self.transport.loseConnection()
def testTimeout(self):
LoopingCall(work, self, duration=0.1).start(2)
with ShouldRaise(TimeoutError(0.02, 'Deferred')):
yield waitForThreads(timeout=0.02)
cancelDelayedCalls()
def _cancelledToTimedOutError(value, timeout):
if isinstance(value, failure.Failure):
value.trap(CancelledError)
raise TimeoutError(timeout, "Deferred")
return value
