Python Deferred.errback方法代码示例

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
        def indx_cb(indx):
            self.logger.debug("Created INDXClient.")
            prep_d = Deferred()

            if self.try_nike_login():
                self.logger.debug("Successfully logged in to Nike.com.")
            else:
                self.logger.error("Failed to log in to Nike.com.")
                prep_d.errback("Failed to log in to Nike.com.")
                
            def objects_cb(harvester, indx=indx):
                self.logger.debug("Found or created all 4 time series.")
                self.logger.debug("Found or created harvester. {0}".format(harvester))

                def wait(x):
                    self.logger.debug("Harvested! Suspending execution for 6 hours at {0}.".format(datetime.now().isoformat()))
                    sleep(21600)
                    prep_d.callback(None)

                if harvester:
                    if "zeros_from" in harvester :
                        self.zeros = datetime.strptime(harvester["zeros_from"][0]["@value"], "%Y-%m-%dT%H:%M:%S")
                    if "retrieved_to" in harvester :
                        self.retrieved = datetime.strptime(harvester["retrieved_to"][0]["@value"], "%Y-%m-%dT%H:%M:%S")
                    self.harvest(indx, harvester).addCallbacks(wait, prep_d.errback)                    

            self.find_create(indx, self.steps_ts_id, {"http://www.w3.org/2000/01/rdf-schema#label":"Nike+ Steps Time Series", "http://www.w3.org/1999/02/22-rdf-syntax-ns#type":"http://purl.org/linked-data/cube#Dataset"}).addCallbacks(
                lambda x: self.find_create(indx, self.calories_ts_id, {"http://www.w3.org/2000/01/rdf-schema#label":"Nike+ Calories Time Series", "http://www.w3.org/1999/02/22-rdf-syntax-ns#type":"http://purl.org/linked-data/cube#Dataset"}), prep_d.errback).addCallbacks(
                lambda x: self.find_create(indx, self.stars_ts_id, {"http://www.w3.org/2000/01/rdf-schema#label":"Nike+ Stars Time Series", "http://www.w3.org/1999/02/22-rdf-syntax-ns#type":"http://purl.org/linked-data/cube#Dataset"}), prep_d.errback).addCallbacks(
                lambda x: self.find_create(indx, self.fuel_ts_id, {"http://www.w3.org/2000/01/rdf-schema#label":"Nike+ Fuel Time Series", "http://www.w3.org/1999/02/22-rdf-syntax-ns#type":"http://purl.org/linked-data/cube#Dataset"}), prep_d.errback).addCallbacks(
                lambda x: self.find_create(indx, self.harvester_id, {"http://www.w3.org/2000/01/rdf-schema#label":"INDX Nike+ Harvester extra info"}), prep_d.errback).addCallbacks(objects_cb, prep_d.errback)   
            return prep_d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
class JsonResponseProtocol(Protocol):

    def __init__(self, d):
        self._upstream = d
        self._finished = Deferred()
        self.buf = []

    def getData(self):
        dl = DeferredList([self._finished, self._upstream],
                          fireOnOneErrback=True)

        @dl.addCallback
        def cb(l):
            return l[0][1]

        @dl.addErrback
        def eb(fail):
            return fail.value.subFailure

        return dl

    def dataReceived(self, data):
        self.buf.append(data)

    def connectionLost(self, reason):
        try:
            data = json.loads("".join(self.buf))
        except Exception, e:
            self._finished.errback(e)
        else:

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
    def test_wb_connect_after_timeout(self):
        """
        Test an odd error scenario. If the zookeeper client succeeds in
        connecting after a timeout, the connection should be closed, as
        the connect deferred has already fired.
        """
        mock_client = self.mocker.patch(self.client)
        mock_client.close()

        def close_state():
            # Ensure the client state variable is correct after the close call.
            self.client.connected = False

        self.mocker.call(close_state)
        self.mocker.replay()

        task = DelayedCall(1, lambda: 1, None, None, None, None)
        task.called = True

        d = Deferred()
        d.errback(ConnectionTimeoutException())

        self.client._cb_connected(
            task, d, None, zookeeper.CONNECTED_STATE, "/")

        self.failUnlessFailure(d, ConnectionTimeoutException)
        return d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
    def test_process_notifications(self):
        twisted.internet.base.DelayedCall.debug = True
        self._connect()
        self.proto.uaid = str(uuid.uuid4())

        # Swap out fetch_notifications
        self.proto.ap_settings.storage.fetch_notifications = Mock(
            return_value=[]
        )

        self.proto.process_notifications()

        # Grab a reference to it
        notif_d = self.proto._notification_fetch

        # Run it again to trigger the cancel
        self.proto.process_notifications()

        # Tag on our own to follow up
        d = Deferred()

        # Ensure we catch error outs from either call
        notif_d.addErrback(lambda x: d.errback(x))

        def wait(result):
            eq_(self.proto._notification_fetch, None)
            d.callback(True)
        self.proto._notification_fetch.addCallback(wait)
        self.proto._notification_fetch.addErrback(lambda x: d.errback(x))
        return d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
def test():
    d = Deferred()
    d.addCallbacks(gotPoets, gotFailed)
    # traceback.print_stack()
    # d.callback('tips poetm short')
    d.errback(Exception('tips poetm shorts'))
    print "....end....."

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
def execute(cmd, env=None, path=None, reactor=None):
    """ Execute a command using twisted's Process Protocol and returns a
        Deferred firing when the command as terminated.

        @param cmd:         Command which should be executed. It has to be a
                            tuple containing the executable as first argument
                            and all additional arguments which will be passed
                            to the executable.
        @type  cmd:         tuple

        @param env:         Can be used to use custom environment variables to
                            execute the command. If argument is omitted the
                            environment of os.environ is used.
        @type  env:         dict

        @param path:        Path which will be used as working directory to
                            execute the command. If argument is omitted the
                            current directory is used.
        @type  path:        str

        @param reactor:     Reference to twisted's reactor. If argument is
                            omitted the standard twisted reactor is imported and
                            used.
        @type  reactor:     twisted::reactor
    """
    deferred = Deferred()
    protocol = _ProcessProtocol(' '.join(cmd), deferred)

    try:
        reactor.spawnProcess(protocol, cmd[0], cmd, env, path)
    except OSError:
        e = ExecutionError('Command could not be executed.')
        deferred.errback(Failure(e))

    return deferred

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
    def auth_plain(self, username, password):
        """ Plain authentication. """
        return_d = Deferred()
        try:
            self.is_authed = False

            url = "{0}auth/login".format(self.address)
            values = {"username": username, "password": password}

            self._debug("Calling auth_plain")     

            # TODO change client.post etc to be async using twisted web clients
            def responded_cb(status):
                if status['code'] != 200:
                    errmsg = "Authentication failed"
                    self._error(errmsg)
                    raise Exception(errmsg)

                self._debug("Authentication successful")
                self.is_authed = True
                return_d.callback(status)
            
            self.client.post(url, values).addCallbacks(responded_cb, return_d.errback)

        except Exception as e:
            return_d.errback(Failure(e))

        return return_d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
class AsyncCall(object):
    """
    A class to represent an outstanding asynchronous thrift call currently
    being processed by the handler.

    The main purpose of this class is so that the handler can track all pending
    calls, and cancel them when AsyncLoadHandler.shutdown() is called.
    """

    def __init__(self, handler):
        self.deferred = Deferred()
        self.handler = handler

    def callback(self, *args, **kwargs):
        self.deferred.callback(*args, **kwargs)
        self._done()

    def errback(self, *args, **kwargs):
        self.deferred.errback(*args, **kwargs)
        self._done()

    def start(self):
        raise NotImplementedError()

    def cancel(self):
        raise NotImplementedError()

    def _done(self):
        self.handler.async_call_done(self)

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
class txDBInterface:
    def __init__(self, *query):
        self.dbpool = dbpool
        self.resultdf = Deferred()
        self.query = query

    def runResultQuery(self):
        df = self.dbpool.runQuery(*self.query)
        df.addCallbacks(self.onResult, self.onFail)
        return self.resultdf

    def runActionQuery(self):
        df = self.dbpool.runOperation(*self.query)
        df.addCallbacks(self.onResult, self.onFail)
        log.debug("running query: %s" % self.query)
        return self.resultdf

    def onResult(self, result):
        self.resultdf.callback(result)

    def onFail(self, error):
        if isinstance(error, adbapi.ConnectionLost):
            log.info("We lost connection to db. re-running the query")
            return self.runQuery()
        self.resultdf.errback(error)

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
    def get_token(self, boxid):
        """ Get a token for this box. """
        return_d = Deferred()

        try:
            if not self.is_authed:
                return_d.errback(Failure(Exception("Must authenticate before getting token.")))
                return return_d

            url = "{0}auth/get_token".format(self.address)
            values = {"box": boxid, "app": self.appid}

            self._debug("Getting token")

            def responded_cb(status):
                if status['code'] != 200:
                    errmsg = "Getting a token failed"
                    self._error(errmsg)
                    raise Exception(errmsg)

                self._debug("Getting a token was successful: {0}".format(status['token']))
                return_d.callback(status['token'])

            self.client.post(url, values).addCallbacks(responded_cb, return_d.errback)

        except Exception as e:
            return_d.errback(Failure(e))

        return return_d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
def r_getPage(url, *args, **kwargs):
    if FuturesSession != None:
        session = FuturesSession()
        method = kwargs.pop("method", "GET")
        user_agent = kwargs.pop("agent", None)
        if user_agent:
            headers = kwargs.pop("headers", {})
            headers["User-Agent"] = user_agent
            kwargs["headers"] = headers

        def cb_err_ret(err):
            return err

        d = Deferred()
        d.addErrback(cb_err_ret)
        try:

            def bg_cb(sess, resp):
                c = resp.content
                d.callback(c)

            if method == "GET":
                session.get(url, background_callback=bg_cb, *args, **kwargs)
            elif method == "POST":
                kwargs["data"] = kwargs.pop("postdata")
                session.post(url, background_callback=bg_cb, *args, **kwargs)
            return d
        except Exception, err:
            printl("Error: " + str(err), None, "E")
            d.errback(failure.Failure())

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
class BodyCollector(Protocol):
    """
    If you want to accumulate the body of an HTTP response until it is
    all finished and then get the result in a string, then create an
    instance of BodyCollector, call its .start() method to get a
    deferred, and pass the instance of BodyCollector as the argument
    to Response.deliverBody(). When the deferred that it gave you
    calls your callback, it will pass the string containing the HTTP
    response body.
    """
    def __init__(self):
        self.finished = Deferred()
        self.bytesl = []

    def start(self):
        return self.finished

    def dataReceived(self, bytes):
        self.bytesl.append(bytes)

    def connectionLost(self, reason):
        self.reason = reason
        self.bytes = ''.join(self.bytesl)
        if isinstance(reason, ResponseDone):
            self.finished.callback(self)
        else:
            self.finished.errback(reason)

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
 def decorator(self, *args, **kwargs):
     if not self.initialized:
         reactor.callLater(5, INVERSE_SHARED[id(f)], self, *args, **kwargs)
         return
     if self.server_mode:
         if "_remote_call" in kwargs:
             del kwargs["_remote_call"]
             d = maybeDeferred(f, self, *args, **kwargs)
             d.addErrback(lambda x:{"_pb_failure":dumps(x)})
             return d
         return maybeDeferred(f, self, *args, **kwargs)
     try:
         remote_obj = choice(self.remote_objs.values())
     except IndexError:
         d = Deferred()
         d.errback(ComponentException("No active %s "
             "connections." % self.__class__.__name__))
         return d
     kwargs["_remote_call"] = True
     try:
         d = remote_obj.callRemote(
             self.server_methods[id(f)],
             *args,
             **kwargs)
     except pb.DeadReferenceError:
         self.server.disconnect_by_remote_obj(remote_obj)
         return INVERSE_SHARED[id(f)](self, *args, **kwargs)
     d.addCallback(check_response, self, time.time())
     d.addErrback(
         self.trap_shared_disconnect,
         remote_obj,
         INVERSE_SHARED[id(f)],
         *args,
         **kwargs)
     return d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
 def join(self, _):
     def send(_, node):
         factory = NodeClientFactory(OverlayService(self), {"command" : \
                 "join","node":self.my_node})
         reactor.connectTCP(node["host"], node["tcp_port"], factory)
         factory.deferred.addCallback(lambda _: node)
         def sendcallback(_):
             return node
         def senderrback(_):
             raise Exception()
         factory.deferred.addCallbacks(sendcallback,senderrback)
         return factory.deferred
     def success(node):
         coordinator = node
     def error(e):
         self.is_coordinator = True
         self.my_node["id"] = 0
         self.nextid = 1
         self.members[self.my_node["host"]] = self.my_node
         send_log("Notice", "I am coordinator")
         return e
     # search for running loadbalancers and join the overlay network
     initialized = False
     d = Deferred()
     for node in self.config["nodes"]:
         d.addErrback(send, node)
     d.addCallbacks(success, error)
     d.errback(0)
     return d

# 需要导入模块: from twisted.internet.defer import Deferred [as 别名]
# 或者: from twisted.internet.defer.Deferred import errback [as 别名]
    def create_root_box(self, box_name, username, password):
        """ Create a new root box for the user name specified. """
        logging.debug("indx_pg2 create_root_box {0} for user {1}".format(box_name, username))
        result_d = Deferred()

        try:
            if username is None or username == "":
                raise Exception("Username cannot be blank, value was {0}".format(username))
            if box_name is None or box_name == "":
                raise Exception("Box Name cannot be blank, value was {0}".format(box_name))

            def created_cb(empty):
                logging.debug("indx_pg2 create_root_box created_cb")

                def connected_cb(conn):
                    logging.debug("indx_pg2 create_root_box connected_cb")

                    def do_acl(empty):
                        logging.debug("indx_pg2 create_root_box do_acl")
                        user = IndxUser(self, username)

                        user.set_acl(box_name, "@indx", {"read": True, "write": False, "control": False, "owner": False}).addCallbacks(result_d.callback, result_d.errback)

                    conn.runOperation("UPDATE tbl_users SET root_box = %s WHERE username = %s", [box_name, username]).addCallbacks(do_acl, result_d.errback)

                self.connect_indx_db().addCallbacks(connected_cb, result_d.errback)

            self.create_box(box_name, username, password).addCallbacks(created_cb, result_d.errback)

        except Exception as e:
            failure = Failure(e)
            logging.error("indx_pg2 create_root_box error, calling errback. Error is: {0}".format(e))
            result_d.errback(failure)

        return result_d