Python Deferred.addBoth方法代码示例

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
 def ping(self):
     if self.socket is not None :
         pingid = self.ping_counter.next()
         defer = Deferred()
         self.ping_callbacks[pingid] = defer
         
         log.msg('Ping {0} devicehive server.'.format(pingid))
         self.socket.send_frame(True, WS_OPCODE_PING, pingid)
         
         # I cannot move it into decorator logic because I need a reference to
         # a function which is clousered to a local scope.
         def on_timeout():
             if pingid in self.ping_callbacks :
                 defer = self.ping_callbacks.pop(pingid)
                 defer.errback(WebSocketError('Ping {0} timeout.'.format(pingid)))
         timeout_defer = reactor.callLater(self.timeout, on_timeout)
         def cancel_timeout(result, *args, **kwargs):
             if timeout_defer.active() :
                 log.msg('Cancelling timeout function call for ping {0}.'.format(pingid))
                 timeout_defer.cancel()
             return result
         defer.addBoth(cancel_timeout)
         
         return defer
     else :
         return fail(WebSocketError('Failed to send ping to the server. Websocket is not established.'))

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
        def news_response(response):
            if response.code != 200:
                news_received_fail(response)
            else:
                def process_body(response_content):
                    news_stats = json.loads(response_content)
                    log.msg('News stats from server: %s' % news_stats)
                    if not news_stats:
                        log.err('Could not find news stats with ids %s' % news_ids)
                    else:
                        if action:
                            assert (len(news_stats) == 1)
                        for stat in news_stats:
                            news_id = stat['news_id']
                            news = self._news[news_id]
                            news.news_id = news_id
                            news.app_ids.update(stat['app_ids'])
                            news.read_count += stat['read_count']
                            news.users_that_rogered = set(stat['users_that_rogered'])
                            self._news_read_updates.add(news_id)
                            if action:
                                if action == 'roger':
                                    news.users_that_rogered.add(account)
                                elif action == 'read':
                                    news.read_count += 1
                        if callback:
                            stats = {news_info['news_id']: NewsInfo.serialize(self._news[news_info['news_id']], friends,
                                                                              account) for news_info in news_stats}
                            callback(stats)

                finished = Deferred()
                response.deliverBody(ReceiverProtocol(finished))
                finished.addBoth(process_body)

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
def make_deferred_with_timeout(canceller=None, timeout=None, timeout_msg=None,
                               **timeout_msg_kwargs):
    d = Deferred(canceller=canceller)

    if (timeout is not None) and (timeout >= 0):
        from twisted.internet import reactor

        timeout_msg_kwargs.update(timeout=timeout)

        if not timeout_msg:
            timeout_msg = 'User timeout of %(timeout)s caused failure.'

        timeout_msg %= timeout_msg_kwargs

        def on_timeout():
            if not d.called:
                d.errback(PoolTimeout(timeout_msg))

        timeout_call = reactor.callLater(timeout, on_timeout)

        def cancel_timeout(result):
            if timeout_call.active():
                timeout_call.cancel()
            return result

        d.addBoth(cancel_timeout)

    return d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
class _BufferedResponse(proxyForInterface(IResponse)):
    def __init__(self, original):
        self.original = original
        self._buffer = []
        self._waiters = []
        self._waiting = None
        self._finished = False
        self._reason = None

    def _deliverWaiting(self, reason):
        self._reason = reason
        self._finished = True
        for waiter in self._waiters:
            for segment in self._buffer:
                waiter.dataReceived(segment)
            waiter.connectionLost(reason)

    def deliverBody(self, protocol):
        if self._waiting is None and not self._finished:
            self._waiting = Deferred()
            self._waiting.addBoth(self._deliverWaiting)
            self.original.deliverBody(
                _BodyBufferingProtocol(
                    protocol,
                    self._buffer,
                    self._waiting
                )
            )
        elif self._finished:
            for segment in self._buffer:
                protocol.dataReceived(segment)
            protocol.connectionLost(self._reason)
        else:
            self._waiters.append(protocol)

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
def callRemote(rpc_client, method_name, *params, **kwargs):
    assert isinstance(rpc_client, JSONClient), 'rpc_client must be an instance of JSONClient'

    deferred = rpc_client.callRemote(method_name, *params)
    print'%s' % consoleRootName(rpc_client.protocolName), method_name, params

    onSuccess = kwargs.get('onSuccess', None)
    if onSuccess and callable(onSuccess):
        deferred.addCallback(onSuccess)
    else:
        deferred.addCallback(onResponseSuccess)

    onError = kwargs.get('onError', None)
    if onError and callable(onError):
        deferred.addErrback(onError)
    else:
        deferred.addErrback(onResponseError)

    # chain try stop reactor, so we can free the response functions to call it
    stopDeferred = Deferred()
    stopDeferred.addBoth(tryStopReactor, rpc_client)

    # when results came back success or error, fire stopDeferred callBacks
    deferred.chainDeferred(stopDeferred)

    return deferred

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
    def test_disconnectedOnError(self):
        """
        If the event handler raises an exception, the event is removed from the
        reactor and the handler's C{connectionLost} method is called in the I/O
        thread and the exception is logged.
        """
        reactorThreadID = getThreadID()
        reactor = self.buildReactor()
        event = win32event.CreateEvent(None, False, False, None)

        result = []
        finished = Deferred()
        finished.addBoth(result.append)
        finished.addBoth(lambda ignored: reactor.stop())

        listener = Listener(finished)
        reactor.addEvent(event, listener, 'brokenOccurred')
        reactor.callWhenRunning(win32event.SetEvent, event)
        self.runReactor(reactor)

        self.assertIsInstance(result[0], Failure)
        result[0].trap(RuntimeError)

        self.assertEqual(reactorThreadID, listener.connLostThreadID)
        self.assertEqual(1, len(self.flushLoggedErrors(RuntimeError)))

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
 def fetched(self, response):
     d = Deferred()
     response.deliverBody(BodyReturner(d, verbose=self.verbose))
     d.addCallback(json.loads)
     if self.verbose or self.debug:
         d.addBoth(self.logLoaded)
     return d.addCallback(IDrawingEngine(self).update)

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
def run(reactor, command, **kwargs):
    """
    Run a process and kill it if the reactor stops.

    :param reactor: Reactor to use.
    :param list command: The command to run.

    :return Deferred: Deferred that fires when the process is ended.
    """
    if 'env' not in kwargs:
        kwargs['env'] = os.environ

    action = RUN_ACTION(command=command)

    protocol_done = Deferred()
    protocol = CommandProtocol(deferred=protocol_done, action=action)

    with action.context():
        protocol_done = DeferredContext(protocol_done)
        reactor.spawnProcess(protocol, command[0], command, **kwargs)

        def unregister_killer(result, trigger_id):
            try:
                reactor.removeSystemEventTrigger(trigger_id)
            except:
                # If we can't remove the trigger, presumably it has already
                # been removed (or run). In any case, there is nothing sensible
                # to do if this fails.
                pass
            return result
        trigger_id = reactor.addSystemEventTrigger(
            'before', 'shutdown', protocol.transport.signalProcess, 'TERM')
        protocol_done.addBoth(unregister_killer, trigger_id)

        return protocol_done.addActionFinish()

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
    def test_ws_unregister_fail(self):
        patcher = patch('autopush.websocket.log', spec=True)
        mock_log = patcher.start()
        self._connect()
        self.proto.uaid = str(uuid.uuid4())
        chid = str(uuid.uuid4())

        d = Deferred()
        d.addBoth(lambda x: patcher.stop())

        # Replace storage delete with call to fail
        table = self.proto.ap_settings.storage.table
        delete = table.delete_item

        def raise_exception(*args, **kwargs):
            # Stick the original back
            table.delete_item = delete
            raise Exception("Connection problem?")

        table.delete_item = Mock(side_effect=raise_exception)
        self._send_message(dict(messageType="unregister",
                                channelID=chid))

        def wait_for_times():  # pragma: nocover
            if len(mock_log.mock_calls) > 0:
                eq_(len(mock_log.mock_calls), 1)
                d.callback(True)
                return
            reactor.callLater(0.1, wait_for_times)

        reactor.callLater(0.1, wait_for_times)
        return d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
class ProgramExecutionService(InternalServiceMixin, Service):
    """



    """


    def __init__(self, program_exec, time_between_exec=0,
                        protocol=DefaultProcessProtocol, **kwargs):
        super(ProgramExecutionService, self).__init__(**kwargs)
        self.program_exec = program_exec
        self.delay = time_between_exec
        self.protocol = protocol
        self.started = False
        self.stopDeferred = None
        self.process = None


    def startService(self):
        super(ProgramExecutionService, self).startService()
        self.started = True
        self._run_process()


    def stopService(self):
        super(ProgramExecutionService, self).stopService()
        self.started = False
        if self.process and self.process.pid:
            self.stopDeferred = Deferred()
            def cb(arg):
                self.stopDeferred = None
            self.stopDeferred.addBoth(cb)
            try:
                self.process.signalProcess("TERM")
            except ProcessExitedAlready:
                pass # No op(prevent race condition causing problem)
            return self.stopDeferred


    def _run_process(self):
        if self.stopDeferred is not None:
            self.stopDeferred.callback(True)
            return # Shutting down. So we fire the callback when the process has terminated.
                    # We won't need to do any more processing so return.
        if not self.started:
            return # Service not running, so don't start the process
        if self.process and self.process.pid:
            return # Existing process still running.

        protocol = _InternalProcessProtocol(_run_process, self.protocol())
        if self.delay > 0:
            self._reactor.callLater(_spawn_process, self.delay, protocol)
        else:
            _spawn_process(protocol)


    def _spawn_process(self, protocol):
        self.process = self._reactor.spawnProcess(protocol, self.command[0], self.command);

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
 def got_response(response):
     status_code = response.code
     finished = Deferred()
     response.deliverBody(ReceiverProtocol(finished))
     if status_code == 200:
         finished.addBoth(lambda body: _send_reply('result', body))
     else:
         finished.addBoth(lambda body: _send_reply('error', body))
     return finished

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
        def onResponse(response):
            if response.code != 200:
                onRequestComplete(None)
                return long_url

            bodyReceived = Deferred()
            response.deliverBody(_ResponseCollector(bodyReceived))
            bodyReceived.addBoth(onRequestComplete)
            return bodyReceived

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
 def got_response(response):
     status_code = response.code
     finished = Deferred()
     response.deliverBody(ReceiverProtocol(finished))
     if status_code == 200:
         finished.addBoth(lambda body: log.msg("Posted response to appengine:\nstatus: %s\nbody:\n%s" % (status_code, body)))
     else:
         finished.addBoth(lambda body: log.err("Error posting response to appengine:\nstatus: %s\nbody:\n%s" % (status_code, body)))
     return finished

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
    def getFile(self, url, filepath):
        d = Deferred()
        self.requests.append(url)
        self.called += 1

        def finish(ignored):
            return True
        d.addBoth(finish)
        return d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import addBoth [as 别名]
    def testControlReadvarExchangeEmptyStatusSet(self):
        def final(result):
            self.assertEqual(self.protocol.status, STATE_UNKNOWN)
        d = Deferred()
        d.addBoth(final)
        self.protocol.d = d
        self.protocol.controlReadvarExchange()
        d.cancel()

        return d