Python ClientCreator.addCallback方法代码示例

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
 def connectClient(self):
     d = ClientCreator(reactor, txprotobuf.Protocol).connectTCP(self.port.getHost().host, self.port.getHost().port)
     def setProtocol(protocol):
         self.protocols.append(protocol)
         return protocol
     d.addCallback(setProtocol)
     return d

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
 def connect(self):
     spec = txamqp.spec.load(self.config.spec())
     delegate = TwistedDelegate()
     d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=self.config.vhost(), spec=spec)\
         .connectTCP(self.config.host(), self.config.port())
     d.addCallback(self.got_connection)
     self.d = defer.Deferred()
     yield self.d

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
    def __init__(self):
        spec = txamqp.spec.load('amqp-spec-0-9-1.xml')
        self.connected = False
        d = ClientCreator(reactor, AMQClient, delegate=TwistedDelegate(), vhost='/',
                spec=spec).connectTCP('127.0.0.1', 5672)
        d.addCallback(self.amqp_connected)

        self.flowCache = {}
        self.flowSeen = []

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
def main():
    creator = ClientCreator(reactor,
                          TTwisted.ThriftClientProtocol,
                          Infrastructure.Client,
                          TBinaryProtocol.TBinaryProtocolFactory(),
                          ).connectTCP(config.IAAS_INTERFACE_IPV4, config.IAAS_PORT)
    creator.addCallback(lambda conn: conn.client)
    creator.addCallback(connected)
    reactor.run()

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
            def callback(res): # res zawiera dane serwera na ktorym moze byc klucz
                # podłączamy się do niego
                d1 = ClientCreator(reactor, amp.AMP).connectTCP(res['address'], res['port'])
                d1.addCallback(lambda p: p.callRemote(commands.Get, key=key))

                def trapError(result):
                    result.trap(Exception)
                    raise result.type()
                d1.addErrback(trapError)
                
                return d1 # deffer, który zawierać będzie wynik metody get na właściwym serwerze

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
def setup(vm):
    print 'Connecting with new domain...'
    
    creator = ClientCreator(reactor,
                          TTwisted.ThriftClientProtocol,
                          RelayService.Client,
                          TBinaryProtocol.TBinaryProtocolFactory(),
                          ).connectTCP(DEFAULT_SETUP_IP, config.RELAY_PORT)
    creator.addCallback(lambda conn: conn.client)
    
    creator.addCallback(connection_established, vm)
    creator.addErrback(error, vm)

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
 def addcall(self, obj, callback=None, **kwargs):
     d = ClientCreator(reactor, amp.AMP).connectTCP(self.address, self.port)
     d.addCallback(lambda p: p.callRemote(obj, **kwargs))
     if callback is None:
         def callback(res):
             print "Otrzymano: ", res
     d.addCallback(callback)
     def trapError(result):
         result.trap(Exception)
         print "Błąd!: {0}".format(result.type)
     d.addErrback(trapError)
     return d

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
 def connect(self):
     d = ClientCreator(reactor,
             TTwisted.ThriftClientProtocol,
             Scheduler.Client,
             TBinaryProtocol.TBinaryProtocolFactory(),
         ).connectTCP(self.host, 
             self.port, self.timeout)
     d.addCallback(self.set_connect)
     d.addErrback(self.close_conn)
     log.msg("try connect to Master[%s:%s]" % \
         (self.host, self.port))
     return d

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
 def new_node(res2):
     # dostajemy jego db, i nastepnika
     self.node = Node(self.address, self.port, 
     self.key, loads(res2['stop']),
         Neighbor(loads(res2['node']), res2['address'], res2['port']), 
         Neighbor(res['node'], res['address'], res['port']),
         loads(res2['db']))
     # dodajemy node do ProtoFactory bo tego mu brakuje
     self.pf.node = self.node
     
     # kontaktujemy się z następnikiem i informujemy, że jesteśmy jego poprzednikiem
     d2 = ClientCreator(reactor, amp.AMP).connectTCP(res2['address'], res2['port'])
     d2.addCallback(lambda p: p.callRemote(commands.NewPrev, node=dumps(self.key), address=self.address, port=self.port))

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
    def start(self):
        vhost = self.amqp_conn['vhost']
        host = self.amqp_conn['host']
        port = self.amqp_conn['port']

        d = ClientCreator(reactor,
                          AMQClient,
                          delegate=TwistedDelegate(),
                          vhost=vhost,
                          spec=self.spec).connectTCP(host, port)

        d.addCallback(self.gotConnection)
        d.addErrback(self.whoops)

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
def _try_connecting(domain, defer):
    '''
    Connects with the domain's Relay service. If it does not respond in 5 seconds
    it is assumed that the domain is not available right now 
    '''
    creator = ClientCreator(reactor,
                          TTwisted.ThriftClientProtocol,
                          RelayService.Client,
                          TBinaryProtocol.TBinaryProtocolFactory(),
                          ).connectTCP(domain, config.RELAY_PORT, timeout=10)
    creator.addCallback(lambda conn: conn.client)
    
    creator.addCallback(lambda value: defer.callback(True))
    creator.addErrback(lambda value: defer.callback(False))

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
def main(all_args=None):
    """The main"""
    all_args = all_args or []
    parser = optparse.OptionParser()
    options, args = parse_cmd_line(parser, all_args)
    (port, example, message, count_, topics) = check_cmd_line(
        options, args, parser.error)

    host = 'localhost'
    vhost = '/'
    username = 'guest'
    password = 'guest'
    spec = txamqp.spec.load('your_specs_path.xml')

    delegate = TwistedDelegate()

    d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=vhost,
                      spec=spec).connectTCP(host, port)

    d.addCallback(gotConnection, username, password)
    if example in PUBLISH_EXAMPLES:
        d.addCallback(ALL_EXAMPLES[example], message, count_)
    else:
        d.addCallback(ALL_EXAMPLES[example], topics)
    d.addCallback(publisher_cleanup)
    d.addErrback(lambda f: sys.stderr.write(str(f)))
    reactor.run()

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
 def configure_domain(self, clone_entry):
     '''
     Reconfigures a domain by running the reconfiguration drone 
     '''
     
     print 'Connecting with new domain.'
     creator = ClientCreator(reactor,
                           TTwisted.ThriftClientProtocol,
                           RelayService.Client,
                           TBinaryProtocol.TBinaryProtocolFactory(),
                           ).connectTCP(DEFAULT_SETUP_IP, config.RELAY_PORT, timeout=10)
     creator.addCallback(lambda conn: conn.client)
     creator.addCallback(self._launch_drone, clone_entry)
     creator.addErrback(self._configuration_error, clone_entry)

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
def main(all_args=None):
    """The main"""
    #    all_args = all_args or []
    #    parser = optparse.OptionParser()
    #    options, args = parse_cmd_line(parser, all_args)
    #    (port, example, message, count_, topics) = check_cmd_line(
    #        options, args, parser.error)

    host = "localhost"
    port = 5672
    vhost = "/"
    username = "guest"
    password = "guest"
    example = "publish2"
    topics = "#"
    message = "hello"
    count = 1000

    spec = txamqp.spec.load("./specs/rabbitmq/amqp0-8.stripped.rabbitmq.xml")

    delegate = TwistedDelegate()

    d = ClientCreator(reactor, AMQClient, delegate=delegate, vhost=vhost, spec=spec).connectTCP(host, port)

    d.addCallback(gotConnection, username, password)
    if example in PUBLISH_EXAMPLES:
        d.addCallback(ALL_EXAMPLES[example], message, count)
    else:
        d.addCallback(ALL_EXAMPLES[example], topics)
    d.addCallback(publisher_cleanup)
    d.addErrback(lambda f: sys.stderr.write(str(f)))
    reactor.run()

# 需要导入模块: from twisted.internet.protocol import ClientCreator [as 别名]
# 或者: from twisted.internet.protocol.ClientCreator import addCallback [as 别名]
 def _makeNewProtocol(self, tosend):
     import twisted.internet.reactor as reactor
     deferred = Deferred()
     def makeProtocol():
         return SoapProtocol(con=self.con)
     def sendPacket(protocol):
         if protocol is None:
             return # silently fail - log this? TODO
         protocol.sendPacket(tosend).addCallback(deferred.callback)
         return protocol
     conn_d = ClientCreator(reactor, makeProtocol).connectTCP(
             host=self.con._message_maker._host, port=self.con._message_maker._port)
     conn_d.addCallback(sendPacket)
     conn_d.addCallbacks(self._newProtocolConnected, self._onConnectionError)
     return deferred