twisted.internet.defer.CancelledError

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 7

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, ))

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)

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)

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)

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())

Example 6

Project: magic-wormhole Source File: transit.py
Function: cancel
    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

Example 7

Project: txpostgres Source File: test_retrying.py
Function: test_cancel
    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)

Example 8

Project: greplin-twisted-utils Source File: wait.py
Function: wait
  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

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

Example 10

Project: txjason Source File: test_client.py
Function: test_time_out
    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)

Example 11

Project: txjason Source File: test_client.py
Function: test_timeout_argument
    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)

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)

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)

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)

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)

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()

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))

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)

Example 19

Project: txsocksx Source File: test_client.py
Function: test_noprotocolfromwrappedfactory
    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)

Example 20

Project: txsocksx Source File: test_client.py
Function: test_noprotocolfromwrappedfactory
    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)

Example 21

Project: mythbox Source File: test_task.py
Function: test_cancel
    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

Example 22

Project: lbry Source File: FileStreamer.py
Function: stop_producing
    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()

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)

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

Example 25

Project: SubliminalCollaborator Source File: test_task.py
Function: test_cancel
    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

Example 26

Project: SubliminalCollaborator Source File: test_xmlrpc.py
Function: test_cancel
    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

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())

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)

Example 29

Project: scrapy Source File: http11.py
Function: cb_bodyready
    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

Example 30

Project: scrapy Source File: client.py
Function: should_retry
    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

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

Example 32

Project: magic-wormhole Source File: test_transit.py
Function: test_cancel
    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)

Example 33

Project: magic-wormhole Source File: test_transit.py
Function: test_cancel
    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)

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

Example 35

Project: txpostgres Source File: txpostgres.py
    def _handleCancellation(self, f):
        f.trap(psycopg2.extensions.QueryCanceledError)
        return failure.Failure(defer.CancelledError())

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

Example 37

Project: p2pool-n Source File: deferral.py
Function: start
    def start(self, period):
        assert not self.running
        self.running = True
        self._df = self._worker(period).addErrback(lambda fail: fail.trap(defer.CancelledError))

Example 38

Project: txsocksx Source File: test_client.py
Function: test_cancellation
    def test_cancellation(self):
        fac, proto = self.makeProto('', 0, None)
        fac.deferred.cancel()
        self.assert_(self.aborted)
        return self.assertFailure(fac.deferred, defer.CancelledError)

Example 39

Project: txmsgpackrpc Source File: handler.py
    def _cancelWaitForEmptyPool(self, deferred):
        self._waitingForEmptyPool.discard(deferred)
        deferred.errback(defer.CancelledError())

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()