Here are the examples of the python api twisted.internet.defer.CancelledError taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
40 Examples
3
Example 1
Project: airpnp Source File: device_discovery.py
def _device_error(self, fail, udn):
"""Handle error that occurred when building a device."""
if not fail.check(defer.CancelledError):
del self._builders[udn]
if fail.check(DeviceRejectedError):
device = fail.value.device
log.msg('Adding device %s to ignore list, because %s' %
(device, fail.getErrorMessage()), ll=2)
self._ignored.append(udn)
elif fail.check(error.Error):
if hasattr(fail, 'url'):
msg = "%s when fetching %s" % (str(fail.value), fail.url)
else:
msg = str(fail.value)
log.msg('Adding UDN %s to ignore list, because %s' % (udn, msg), ll=2)
self._ignored.append(udn)
else:
log.err(fail, "Failed to build Device with UDN %s" % (udn, ))
3
Example 2
Project: txrdq Source File: test_dpq.py
def test_cancelQueueAfterGet(self):
"""
When canceling a L{Deferred} from a L{DeferredQueue} that does not
have a result (i.e., the L{Deferred} has not fired), the cancel
causes a L{defer.CancelledError} failure. If the queue has a result
later on, it doesn't try to fire the deferred.
"""
def cb(ignore):
# If the deferred is still linked with the deferred queue, it will
# fail with an AlreadyCalledError
queue.put(obj=None, priority=0)
return queue.get().addCallback(self.assertIdentical, None)
queue = DeferredPriorityQueue()
d = queue.get()
self.assertFailure(d, defer.CancelledError)
d.cancel()
return d.addCallback(cb)
3
Example 3
Project: txmongo Source File: test_cancel.py
def test_protocol_query(self):
tr = proto_helpers.StringTransport()
proto = MongoProtocol()
proto.makeConnection(tr)
d = proto.send_QUERY(Query(query={'x': 42}))
d.cancel()
with AssertCallbackNotCalled(d):
reply = Reply(response_to=1, docuements=[{'x': 42}])
reply_bin = struct.pack("<iiiiqii", 1, *reply[2:8]) + b''.join(reply.docuements)
reply_bin = struct.pack('<i', len(reply_bin) + 4) + reply_bin
proto.dataReceived(reply_bin)
self.failureResultOf(d, defer.CancelledError)
3
Example 4
Project: txmongo Source File: test_cancel.py
def test_protocol_connectionReady(self):
proto = MongoProtocol()
d1 = proto.connectionReady()
d2 = proto.connectionReady()
d1.cancel()
with AssertCallbackNotCalled(d1):
proto.makeConnection(proto_helpers.StringTransport())
self.assertTrue(d2.called)
self.failureResultOf(d1, defer.CancelledError)
3
Example 5
Project: magic-wormhole Source File: test_transit.py
def test_not_forever_cancel_early(self):
c, clock, d0, d, cancelled, result = self._forever_setup()
self.assertEqual((result, cancelled), ([], []))
d.cancel()
self.assertEqual(cancelled, [d0])
self.assertEqual(len(result), 1)
self.assertIsInstance(result[0].value, defer.CancelledError)
self.assertNot(clock.getDelayedCalls())
3
Example 6
def _cancel(self, d):
self.state = "hung up" # stop reacting to anything further
self._error = defer.CancelledError()
self.transport.loseConnection()
# if connectionLost isn't called synchronously, then our
# self._negotiation_d will have been errbacked by Deferred.cancel
# (which is our caller). So if it's still around, clobber it
if self._negotiation_d:
self._negotiation_d = None
3
Example 7
def test_cancel(self):
"""
Cancelling the call causes it to fail with a CancelledError.
"""
self.raiseError = ArbitraryException
everysecond = [1, 1, 1, 1]
d = self.call.start(everysecond)
self.assertEquals(self.calls, 0)
self.clock.advance(1)
self.assertEquals(self.calls, 1)
self.clock.advance(1)
self.assertEquals(self.calls, 2)
d.cancel()
self.clock.advance(1)
self.assertEquals(self.calls, 2)
return self.assertFailure(d, defer.CancelledError)
3
Example 8
def _wait(self, deferred):
"""Waits for the given deferred."""
if self.isRunning():
if deferred:
self.__currentWait = deferred
return deferred.addBoth(self.__clearWait)
else:
if deferred:
deferred.cancel()
raise defer.CancelledError
3
Example 9
Project: Telephus Source File: pool.py
def work_on_queue(self, q):
self.logstate('work_on_queue')
self.keep_working = True
d = self.job('queue_getter', q.get)
d.addCallback(self.work_on_request)
d.addCallback(self.maybe_do_more_work, q)
d.addErrback(lambda f: f.trap(defer.CancelledError))
d.addErrback(self.scream_like_a_little_girl)
return d
3
Example 10
def test_timeout(self):
called = []
def eb(r):
called.append(r.value)
payload, d = self.client.getRequest('foo')
d.addErrback(eb)
clock.advance(self.client.timeout - 1)
self.assertFalse(called)
clock.advance(1)
self.assertIsInstance(called[0], defer.CancelledError)
3
Example 11
def test_timeout_argument(self):
called = []
payload, d = self.client.getRequest('foo', timeout=4)
d.addErrback(called.append)
clock.advance(3)
self.assertFalse(called)
clock.advance(1)
self.assertIsInstance(called[0].value, defer.CancelledError)
3
Example 12
Project: txjason Source File: test_netstring.py
def test_callRemote_cancellation_during_request(self):
"""
The Deferred returned by callRemote can be cancelled while waiting on a
response.
"""
self.assertFalse(self.endpoint.connected)
d = self.factory.callRemote('spam')
d.cancel()
self.failureResultOf(d, defer.CancelledError)
3
Example 13
Project: txjason Source File: test_netstring.py
def test_callRemote_timeout(self):
"""
A timeout causes the Deferred returned by callRemote to errback with
CancelledError.
"""
self.assertFalse(self.endpoint.connected)
d = self.factory.callRemote('spam')
self.reactor.advance(10)
self.failureResultOf(d, defer.CancelledError)
3
Example 14
Project: txjason Source File: test_netstring.py
def test_disconnect_callRemote_cancellation(self):
"""
The disconnect method cancels pending callRemote Deferreds.
"""
d = self.factory.callRemote('spam')
self.assertIsNot(self.endpoint.transport, None)
self.factory.disconnect()
self.assertIs(self.endpoint.transport, None)
self.assertEqual(len(self.flushLoggedErrors(FakeDisconnectedError)), 1)
self.failureResultOf(d, defer.CancelledError)
3
Example 15
Project: Tickery Source File: adder.py
def _reportCancelled(self, fail, screenname):
"""
A user addition was cancelled. Log it and absorb the failure.
"""
fail.trap(defer.CancelledError)
log.msg('Addition of user %r cancelled.' % screenname)
3
Example 16
Project: Piped Source File: web_provider.py
def _delayed_errback(self, failure, request):
if failure.check(defer.CancelledError):
# The deferred was cancelled, most likely because the client abandoned the request, so do nothing.
return
self.site.log_exception(failure)
body = self._get_error_body(request, failure)
request.setResponseCode(http.INTERNAL_SERVER_ERROR)
request.setHeader('content-type', 'text/html')
request.setHeader('content-length', str(len(body)))
request.write(body)
request.finish()
3
Example 17
Project: Piped Source File: test_util.py
def test_cancellable(self):
waiting = util.wait(180)
waiting.cancel()
# trial will report the reactor as unclean if the call to cancel does not cancel the delayedcall
waiting.addErrback(lambda failure: failure.trap(defer.CancelledError))
3
Example 18
Project: txsocksx Source File: test_client.py
def test_cancellationBeforeFailure(self):
fac, proto = self.makeProto('', 0, None)
fac.deferred.cancel()
proto.connectionLost(connectionLostFailure)
self.assert_(self.aborted)
return self.assertFailure(fac.deferred, defer.CancelledError)
3
Example 19
def test_noProtocolFromWrappedFactory(self):
wrappedFac = FakeFactory(returnNoProtocol=True)
fac, proto = self.makeProto('', 0, wrappedFac)
proto.dataReceived('\x05\x00\x05\x00\x00\x01444422')
self.assert_(self.aborted)
return self.assertFailure(fac.deferred, defer.CancelledError)
3
Example 20
def test_noProtocolFromWrappedFactory(self):
wrappedFac = FakeFactory(returnNoProtocol=True)
fac, proto = self.makeProto('', 0, wrappedFac)
proto.dataReceived('\x00\x5a\x00\x00\x00\x00\x00\x00xxxxx')
self.assert_(self.aborted)
return self.assertFailure(fac.deferred, defer.CancelledError)
3
Example 21
def test_cancel(self):
"""
The L{Deferred} returned by L{task.deferLater} can be
cancelled to prevent the call from actually being performed.
"""
called = []
clock = task.Clock()
d = task.deferLater(clock, 1, called.append, None)
d.cancel()
def cbCancelled(ignored):
# Make sure there are no calls outstanding.
self.assertEquals([], clock.getDelayedCalls())
# And make sure the call didn't somehow happen already.
self.assertFalse(called)
self.assertFailure(d, defer.CancelledError)
d.addCallback(cbCancelled)
return d
3
Example 22
def stopProducing(self):
self._running = False
self._file.close()
self._deferred.addErrback(lambda err: err.trap(defer.CancelledError))
self._deferred.addErrback(lambda err: err.trap(error.ConnectionDone))
self._deferred.cancel()
self._request.unregisterProducer()
self._request.finish()
3
Example 23
Project: bitmask_client Source File: backend.py
def _done_action(self, failure, d):
"""
Remove the defer from the ongoing list.
:param failure: the failure that triggered the errback.
None if no error.
:type failure: twisted.python.failure.Failure
:param d: defer to remove
:type d: twisted.internet.defer.Deferred
"""
if failure is not None:
if failure.check(defer.CancelledError):
logger.debug("A defer was cancelled.")
else:
logger.error("There was a failure - {0!r}".format(failure))
logger.error(failure.getTraceback())
if d in self._ongoing_defers:
self._ongoing_defers.remove(d)
3
Example 24
Project: txtorcon Source File: circuit.py
def build_timeout_circuit(tor_state, reactor, path, timeout, using_guards=False):
"""
returns a deferred which fires when the
circuit build succeeds or fails to build.
CircuitBuildTimedOutError will be raised unless we
receive a circuit build result within the `timeout` duration.
"""
d = tor_state.build_circuit(path, using_guards)
reactor.callLater(timeout, d.cancel)
def trap_cancel(f):
f.trap(defer.CancelledError)
return Failure(CircuitBuildTimedOutError("circuit build timed out"))
d.addCallback(lambda circuit: circuit.when_built())
d.addErrback(trap_cancel)
return d
3
Example 25
def test_cancel(self):
"""
The L{Deferred} returned by L{task.deferLater} can be
cancelled to prevent the call from actually being performed.
"""
called = []
clock = task.Clock()
d = task.deferLater(clock, 1, called.append, None)
d.cancel()
def cbCancelled(ignored):
# Make sure there are no calls outstanding.
self.assertEqual([], clock.getDelayedCalls())
# And make sure the call didn't somehow happen already.
self.assertFalse(called)
self.assertFailure(d, defer.CancelledError)
d.addCallback(cbCancelled)
return d
3
Example 26
def test_cancel(self):
"""
A deferred from the Proxy can be cancelled, disconnecting
the L{twisted.internet.interfaces.IConnector}.
"""
def factory(*args, **kw):
factory.f = TestQueryFactoryCancel(*args, **kw)
return factory.f
d = self.proxy(factory).callRemote('add', 2, 3)
self.assertNotEquals(factory.f.connector.state, "disconnected")
d.cancel()
self.assertEqual(factory.f.connector.state, "disconnected")
d = self.assertFailure(d, defer.CancelledError)
return d
2
Example 27
Project: magic-wormhole Source File: test_transit.py
def test_not_forever_timeout(self):
c, clock, d0, d, cancelled, result = self._forever_setup()
self.assertEqual((result, cancelled), ([], []))
clock.advance(2.0)
self.assertEqual(cancelled, [d0])
self.assertEqual(len(result), 1)
self.assertIsInstance(result[0].value, defer.CancelledError)
self.assertNot(clock.getDelayedCalls())
0
Example 28
Project: splash Source File: resources.py
def _on_timeout_error(self, failure, request, timeout=None):
failure.trap(defer.CancelledError)
ex = GlobalTimeoutError({'timeout': timeout})
return self._write_error(request, 504, ex)
0
Example 29
def _cb_bodyready(self, txresponse, request):
# deliverBody hangs for responses without body
if txresponse.length == 0:
return txresponse, b'', None
maxsize = request.meta.get('download_maxsize', self._maxsize)
warnsize = request.meta.get('download_warnsize', self._warnsize)
expected_size = txresponse.length if txresponse.length != UNKNOWN_LENGTH else -1
if maxsize and expected_size > maxsize:
error_message = ("Cancelling download of {url}: expected response "
"size ({size}) larger than "
"download max size ({maxsize})."
).format(url=request.url, size=expected_size, maxsize=maxsize)
logger.error(error_message)
txresponse._transport._producer.loseConnection()
raise defer.CancelledError(error_message)
if warnsize and expected_size > warnsize:
logger.warning("Expected response size (%(size)s) larger than "
"download warn size (%(warnsize)s).",
{'size': expected_size, 'warnsize': warnsize})
def _cancel(_):
txresponse._transport._producer.loseConnection()
d = defer.Deferred(_cancel)
txresponse.deliverBody(_ResponseReader(d, txresponse, request, maxsize, warnsize))
# save response for timeouts
self._txresponse = txresponse
return d
0
Example 30
def _shouldRetry(self, method, exception, bodyProducer):
"""
Indicate whether request should be retried.
Only returns C{True} if method is idempotent, no response was
received, the reason for the failed request was not due to
user-requested cancellation, and no body was sent. The latter
requirement may be relaxed in the future, and PUT added to approved
method list.
"""
if method not in ("GET", "HEAD", "OPTIONS", "DELETE", "TRACE"):
return False
if not isinstance(exception, (RequestNotSent, RequestTransmissionFailed,
ResponseNeverReceived)):
return False
if isinstance(exception, _WrapperException):
for failure in exception.reasons:
if failure.check(defer.CancelledError):
return False
if bodyProducer is not None:
return False
return True
0
Example 31
Project: openross Source File: s3_downloader.py
@time_on_statsd(statsd_name(), 's3_downloader')
def process_image(self, payload, **kwargs):
""" Gets image data from S3.
This attempts to download from s3 settings.ATTEMPTS times and timeouts after
settings.S3_TIMEOUT """
def _create_deferred(timeout=0):
""" Creates a deferred which will run after a given delay """
if settings.USE_BOTO:
dfd = task.deferLater(
reactor, timeout,
threads.deferToThread, self._get_data_from_s3, payload['image_path']
)
return dfd
else:
dfd = task.deferLater(
reactor, timeout, self._get_data_from_s3_tx, payload['image_path']
)
return dfd
def _s3callback(deferred_list_result):
""" When one of the requests has completed, cancel the rest """
[dfd.cancel() for dfd in dfds_list if not dfd.called]
if not deferred_list_result[0]:
raise NoDataInS3Error()
payload['original_image'] = deferred_list_result[0]
return payload
def _timeout_and_fail(dfds_list):
""" If none of the defers has finished by (attempts+1)*timeout then
cancel and return an error """
[dfd.cancel() for dfd in dfds_list if not dfd.called]
def _surpress_cancel_error(result):
if isinstance(result, defer.CancelledError):
pass
# Skip if already exists from cache
if 'original_image' in payload.keys():
return payload
if settings.DEBUG:
log.msg(
"[%s] Starting S3 Download" % datetime.now().isoformat(), logLevel=logging.DEBUG
)
# Make a deferred list of download attempts that have their predefined starting
# times baked into the deferred. Return when any deferred has a successful result
# Keep a list of the original deferred as we cannot access them once in DeferredList
dfds_list = []
for attempt in range(0, settings.S3_ATTEMPTS):
dfds_list.append(_create_deferred(timeout=attempt*settings.S3_TIMEOUT))
dfds_list[-1].addErrback(_surpress_cancel_error)
dfds = defer.DeferredList(dfds_list, fireOnOneCallback=True)
dfds.addCallback(_s3callback)
# Auto cancel requests which don't fire after their max timeout
reactor.callLater(
settings.S3_ATTEMPTS*settings.S3_TIMEOUT, _timeout_and_fail, dfds_list
)
return dfds
0
Example 32
def test_cancel(self):
f = transit.InboundConnectionFactory("owner")
f.protocol = MockConnection
results = []
d = f.whenDone()
d.addBoth(results.append)
self.assertEqual(results, [])
addr1 = address.HostnameAddress("example.com", 1234)
addr2 = address.HostnameAddress("example.com", 5678)
p1 = f.buildProtocol(addr1)
p2 = f.buildProtocol(addr2)
f.connectionWasMade(p1)
f.connectionWasMade(p2)
self.assertEqual(results, [])
d.cancel()
self.assertEqual(len(results), 1)
f = results[0]
self.assertIsInstance(f, failure.Failure)
self.assertIsInstance(f.value, defer.CancelledError)
self.assertEqual(p1._cancelled, True)
self.assertEqual(p2._cancelled, True)
0
Example 33
def test_cancel(self):
owner = MockOwner()
factory = MockFactory()
addr = address.HostnameAddress("example.com", 1234)
c = transit.Connection(owner, None, None, "description")
self.assertEqual(c.state, "too-early")
t = c.transport = FakeTransport(c, addr)
c.factory = factory
c.connectionMade()
d = c.startNegotiation()
results = []
d.addBoth(results.append)
# while we're waiting for negotiation, we get cancelled
d.cancel()
self.assertEqual(t._connected, False)
self.assertEqual(c.state, "hung up")
self.assertEqual(len(results), 1)
f = results[0]
self.assertIsInstance(f, failure.Failure)
self.assertIsInstance(f.value, defer.CancelledError)
0
Example 34
Project: magic-wormhole Source File: transit.py
def _proto_failed(self, f):
# ignore these two, let Twisted log everything else
f.trap(BadHandshake, defer.CancelledError)
pass
0
Example 35
Project: txpostgres Source File: txpostgres.py
def _handleCancellation(self, f):
f.trap(psycopg2.extensions.QueryCanceledError)
return failure.Failure(defer.CancelledError())
0
Example 36
Project: tensor Source File: utils.py
def request(self, url, method='GET', headers={}, data=None, socket=None):
self.timedout = False
if socket:
agent = SocketyAgent(reactor, socket)
else:
if url[:5] == 'https':
if SSL:
agent = Agent(reactor, WebClientContextFactory())
else:
raise Exception('HTTPS requested but not supported')
else:
agent = Agent(reactor)
request = agent.request(method, url,
Headers(headers),
StringProducer(data) if data else None
)
if self.timeout:
timer = reactor.callLater(self.timeout, self.abort_request,
request)
def timeoutProxy(request):
if timer.active():
timer.cancel()
return self.response(request)
def requestAborted(failure):
if timer.active():
timer.cancel()
failure.trap(defer.CancelledError,
error.ConnectingCancelledError)
raise Timeout(
"Request took longer than %s seconds" % self.timeout)
request.addCallback(timeoutProxy).addErrback(requestAborted)
else:
request.addCallback(self.response)
return request
0
Example 37
def start(self, period):
assert not self.running
self.running = True
self._df = self._worker(period).addErrback(lambda fail: fail.trap(defer.CancelledError))
0
Example 38
def test_cancellation(self):
fac, proto = self.makeProto('', 0, None)
fac.deferred.cancel()
self.assert_(self.aborted)
return self.assertFailure(fac.deferred, defer.CancelledError)
0
Example 39
Project: txmsgpackrpc Source File: handler.py
def _cancelWaitForEmptyPool(self, deferred):
self._waitingForEmptyPool.discard(deferred)
deferred.errback(defer.CancelledError())
0
Example 40
Project: lbry Source File: Resources.py
def _responseFailed(self, err, call):
call.addErrback(lambda err: err.trap(error.ConnectionDone))
call.addErrback(lambda err: err.trap(defer.CancelledError))
call.addErrback(lambda err: log.info("Error: " + str(err)))
call.cancel()