def update_cfg(self, resp): if not isinstance(resp, replication.ttypes.query_cfg_response): logger.error('table: %s, query_cfg_response is error', self.name) return None self.query_cfg_response = resp self.app_id = self.query_cfg_response.app_id ds = [] connected_rpc_addrs = {} for partition in self.query_cfg_response.partitions: rpc_addr = partition.primary self.partition_dict[partition.pid.get_pidx()] = rpc_addr if rpc_addr in connected_rpc_addrs or rpc_addr.address == 0: continue host, port = rpc_addr.to_host_port() if rpc_addr in self.session_dict: self.session_dict[rpc_addr].close() d = ClientCreator(reactor, TPegasusThriftClientProtocol, ReplicaSession, TBinaryProtocol.TBinaryProtocolFactory(), None, self.container, self.timeout).connectTCP(host, port, DEFAULT_TIMEOUT) connected_rpc_addrs[rpc_addr] = 1 d.addCallbacks(self.got_conn, self.got_err) ds.append(d) dlist = defer.DeferredList(ds, consumeErrors=True) dlist.addCallback(self.got_results) return dlist
def _connect(self, scheme, host, port): """ Connect to the given host and port, using a transport selected based on scheme. @param scheme: A string like C{'http'} or C{'https'} (the only two supported values) to use to determine how to establish the connection. @param host: A C{str} giving the hostname which will be connected to in order to issue a request. @param port: An C{int} giving the port number the connection will be on. @return: A L{Deferred} which fires with a connected instance of C{self._protocol}. """ cc = ClientCreator(self._reactor, self._protocol) if scheme == 'http': d = cc.connectTCP(host, port) elif scheme == 'https': d = cc.connectSSL(host, port, self._wrapContextFactory(host, port)) else: d = defer.fail(SchemeNotSupported( "Unsupported scheme: %r" % (scheme,))) return d
def connectToGameServer(self, host, port, timeout=5): cc = ClientCreator(reactor, TrosnothClientProtocol) trosnothClient = yield cc.connectTCP(host, port, timeout=timeout) settings = yield trosnothClient.getSettings() defer.returnValue((trosnothClient, settings))
def join(self, passwordGetter): ''' Attempts to connect to this game. Returns a deferred whose callback will be executed with (trosnothClient, authTag). ''' log.info('Attempting to join game on %r', self.server) host, port = self.server p = yield ClientCreator(reactor, amp.AMP).connectTCP(host, port) log.info('Connection established') try: result = yield p.callRemote(authcommands.ConnectToGame, id=self.id) except authcommands.NotAuthenticated: log.info('Not authenticated') yield authenticate(p, host, passwordGetter) log.info('Retrying') result = yield p.callRemote(authcommands.ConnectToGame, id=self.id) finally: if p.transport.connected: p.transport.loseConnection() log.info('Done') trosnothClient, settings = (yield self.connectToGameServer( host, result['port'])) log.info('Got trosnothClient') self.lobby.app.identitySettings.setNick(result['nick']) defer.returnValue((trosnothClient, settings, result['authTag']))
def callback(res): # podłączamy się do niego d1 = ClientCreator(reactor, amp.AMP).connectTCP(res['address'], res['port']) # oznajmiamy mu, że będziemy jego następnikiem d1.addCallback(lambda p: p.callRemote(commands.NewNode, key=dumps(self.key), address=self.address, port=self.port)) 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)) d1.addCallback(new_node)
def __init__(self, host, port, path, fileOrName, username = '******', \ password = '******', writeProgress = None, passive = True, \ supportPartial = False, *args, **kwargs): timeout = 30 # We need this later self.path = path self.resume = supportPartial # Initialize self.currentlength = 0 self.totallength = None if writeProgress and type(writeProgress) is not list: writeProgress = [ writeProgress ] self.writeProgress = writeProgress # Output if isinstance(fileOrName, str): self.filename = fileOrName self.file = None else: self.file = fileOrName creator = ClientCreator(reactor, FTPClient, username, password, passive = passive) creator.connectTCP(host, port, timeout).addCallback(self.controlConnectionMade).addErrback(self.connectionFailed) self.deferred = defer.Deferred()
def StartTalking(self, identifier_from, name_from, identifier_to, name_to): # currently on wx loop # move it to the twisted loop # fetch host and port for that id creator = ClientCreator(reactor, HydrusServerAMP.MessagingClientProtocol) deferred = creator.connectTCP(host, port) # deferred is called with the connection, or an error # callRemote to register identifier_from and name_from as temp login # then add to temp_connections self._temporary_connections[(identifier_from, name_from, identifier_to, name_to)] = connection message = '' # this is just to get the OTR handshake going; it'll never be sent connection.callRemote(HydrusServerAMP.IMMessageServer, identifier_to=identifier_to, name_to=name_to, message=message)
def connect(self, server): self.disconnect() self.server = server if not server: return username = server.getUsername() if not username: username = '******' password = '******' else: password = server.getPassword() host = server.getAddress() passive = server.getPassive() port = server.getPort() timeout = 30 # TODO: make configurable # XXX: we might want to add a guard so we don't try to connect to another host while a previous attempt is not timed out creator = ClientCreator(reactor, FTPClient, username, password, passive=passive) creator.connectTCP(host, port, timeout).addCallback( self.controlConnectionMade).addErrback(self.connectionFailed)
def __init__(self, smtp_host, smtp_port, username="", password=""): """Constructor""" self.host = smtp_host self.port = smtp_port self.client = ClientCreator(reactor, SMTPClient, username, password)\ .connectTCP(self.host, self.port)\ .addErrback(self._connectionFailed)
def connect_client_ivt_to_uni_main(call_uuid=None): global HOST, PORT cc = ClientCreator(reactor, ClientProtocol) df = cc.connectTCP(HOST, PORT) df.addCallback(client_connect_success, call_uuid=call_uuid) df.addErrback(client_connect_fail) return df
def __init__(self, url: str, callback, name: str = ''): self.parameters = URLParameters(url) self.client = ClientCreator(reactor, TwistedProtocolConnection, self.parameters) self.name = name self.connection = None self.callback = callback
def _benchmark(byteCount, clientProtocol): result = {} finished = Deferred() def cbFinished(ignored): result["disconnected"] = time() result["duration"] = result["disconnected"] - result["connected"] return result finished.addCallback(cbFinished) f = ServerFactory() f.protocol = lambda: ServerProtocol(byteCount, finished) server = reactor.listenTCP(0, f) f2 = ClientCreator(reactor, clientProtocol) proto = f2.connectTCP("127.0.0.1", server.getHost().port) def connected(proto): result["connected"] = time() return proto proto.addCallback(connected) proto.addCallback(_write, byteCount) return finished
def connectionMade(self): logshow ("connected") # 在不需要工厂时可以直接使用这个类来产生仅使用一次的客户端连接。这时,协议对象之间没有共享状态,也不需要重新连接。 c = ClientCreator(reactor,Clienttransfer) c.connectTCP("192.168.4.2",3389).addCallback(self.set_protocol) #连接并返回refer,设置callback 参数是新protocol,add之后立即callback? self.transport.pauseProducing() # 代理服务暂停数据接收
def handle_handshake(self, decoded): if 'login' not in decoded: self.send_error_msg("No login specified") return self.username = decoded['login'] if 'password' not in decoded: self.send_error_msg("No password specified") return self.password = decoded['password'] if 'pool' not in decoded: self.send_error_msg("No pool specified") return pool = decoded['pool'] try: self.pool_address, port_str = pool.split(":") self.pool_port = int(port_str) except: self.send_error_msg("Error when parsing pool information") return self.prn("Opening bridge to %s:%d" % (self.pool_address, self.pool_port)) c = ClientCreator(reactor, StratumClient) d = c.connectTCP(self.pool_address, self.pool_port) d.addCallback(self.pool_got_connection)
def doMath(): creator = ClientCreator(reactor, amp.AMP) sumDeferred = creator.connectTCP('127.0.0.1', 1234) def connected(ampProto): return ampProto.callRemote(Sum, a=13, b=81) sumDeferred.addCallback(connected) def summed(result): return result['total'] sumDeferred.addCallback(summed) divideDeferred = creator.connectTCP('127.0.0.1', 1234) def connected(ampProto): return ampProto.callRemote(Divide, numerator=1234, denominator=0) divideDeferred.addCallback(connected) def trapZero(result): result.trap(ZeroDivisionError) print "Divided by zero: returning INF" return 1e1000 divideDeferred.addErrback(trapZero) def done(result): print 'Done with math:', result reactor.stop() defer.DeferredList([sumDeferred, divideDeferred]).addCallback(done)
def connect_to_rez(rez_info): dyno_id = rez_info.get('dyno_id') cc = ClientCreator(reactor, ProcLiteProtocol) (cc.connectSSL(rez_info.get('host'), self.settings.get('proclite_port'), ssl.ClientContextFactory()).addCallback( buildProtoCallback(dyno_id)))
def download_request(self, request, spider): parsed_url = urlparse(request.url) creator = ClientCreator(reactor, FTPClient, request.meta["ftp_user"], request.meta["ftp_password"], passive=request.meta.get("ftp_passive", 1)) return creator.connectTCP(parsed_url.hostname, parsed_url.port or 21).addCallback(self.gotClient, request, parsed_url.path)
def find_node(self, key, address=None, port=None): # find node nie moze byc wywolany jesli self.node jest node ktorego szukamy # if (address is None or port is None): if self.node is None: return # moze jakis wyjatek tu trzeba rzucic else: key, address, port = self.node.find_node(key).unpack() # łączymy się ze znanym węzłem w sieci i poszukujemy rekurencyjnie węzła, który zostanie # naszym następnikiem # d = ClientCreator(reactor, amp.AMP).connectTCP(address, port) d.addCallback( lambda p: p.callRemote(commands.FindNode, key=dumps(key))) def callback(res): res['node'] = loads(res['node']) if res['my_key']: return res else: return self.find_node(key, res['address'], res['port']) d.addCallback(callback) return d
def startService(self): from twisted.internet import reactor creator = ClientCreator(reactor, AMQClient, delegate = TwistedDelegate(), vhost = self.amqp_vhost, spec = txamqp.spec.load(self.amqp_spec_path)) supported_proto = { "TCP": creator.connectTCP, "SSL": creator.connectSSL, } if not (self.amqp_connect_proto in supported_proto): raise Exception("Unsupported amqp_connect_proto {}".format(self.amqp_connect_proto)) #TODO: make loop to try reconnect on failure self._correlation_dict_init() # connect self.connection = yield supported_proto[self.amqp_connect_proto](**self.amqp_connect_kargs) # authenticate yield self.connection.start(self.amqp_start_args) # open channel self.channel = yield self.connection.channel(1) yield self.channel.channel_open() # declare exclusive queue self.r_queue = yield self.channel.queue_declare(exclusive=True, auto_delete=True) # setup queue to consume yield self.channel.basic_consume(queue=self.r_queue.queue, no_ack=True, consumer_tag='cmds') self.queue = yield self.connection.queue('cmds') # start consume self._update_queue_defer() returnValue(None)
def __init__(self, app, host, port, onClose): super(AccountSettingsScreen, self).__init__(app) self.onClose = onClose self.host = host self.port = port area = ScaledArea(50, 140, 924, 570) alpha = 192 if app.displaySettings.alphaOverlays else 255 font = app.screenManager.fonts.bigMenuFont self.tabContainer = TabContainer(self.app, area, font, app.theme.colours.playTabBorder) self.background = elements.SolidRect( self.app, app.theme.colours.playMenu, alpha, Area(AttachedPoint((0, 0), self.tabContainer._getTabRect), TabSize(self.tabContainer))) self.passwordTab = ChangePasswordTab(app, host, onClose=self.close, onSave=self.save) self.tabContainer.addTab(self.passwordTab) self.passwordGetter = self.passwordGUIFactory(self.app) self.elements = [self.background, self.tabContainer] self.protocol = None d = ClientCreator(reactor, amp.AMP).connectTCP(host, port) d.addCallbacks(self.connectionEstablished, self.connectionFailed)
def connectToServer(self, host, port, timeout=7): self.elements = [ self.backdrop, ConnectingScreen(self.app, '%s:%s' % (host, port), onCancel=self.cancelConnecting) ] try: cc = ClientCreator(reactor, TrosnothClientProtocol) self.currentDeferred = cc.connectTCP(host, port, timeout=timeout) trosnothClient = yield self.currentDeferred self.trosnothClient = trosnothClient self.currentDeferred = trosnothClient.getSettings() settings = yield self.currentDeferred self.currentDeferred = None self.connectionEstablished(settings) except Exception as e: self.currentDeferred = None self.trosnothClient = None self.elements = [self.backdrop, self.startupInterface] if not isinstance(e, defer.CancelledError): if isinstance(e, ConnectionFailed): text = str(e.reason) else: text = 'Internal Error' log.exception('Unexpected failure in deferred') d = ConnectionFailedDialog(self.app, text) d.show()
def _cancelConnectTimeoutTest(self, connect): """ Like L{_cancelConnectTest}, but for the case where the L{Deferred} is cancelled after the connection is set up but before it is fired with the resulting protocol instance. """ reactor = MemoryReactorWithConnectorsAndTime() cc = ClientCreator(reactor, Protocol) d = connect(reactor, cc) connector = reactor.connectors.pop() # Sanity check - there is an outstanding delayed call to fire the # Deferred. self.assertEquals(len(reactor.getDelayedCalls()), 1) # Cancel the Deferred, disconnecting the transport just set up and # cancelling the delayed call. d.cancel() self.assertEquals(reactor.getDelayedCalls(), []) # A real connector implementation is responsible for disconnecting the # transport as well. For our purposes, just check that someone told the # connector to disconnect. self.assertTrue(connector._disconnected) return self.assertFailure(d, CancelledError)
def __init__(self, host, port, path, fileOrName, username='******', password='', passive=True, supportPartial=False, *args, **kwargs): timeout = 30 self.path = path self.resume = supportPartial if isinstance(fileOrName, str): self.filename = fileOrName self.file = None else: self.file = fileOrName creator = ClientCreator(reactor, FTPClient, username, password, passive=passive) creator.connectTCP(host, port, timeout).addCallback( self.controlConnectionMade).addErrback(self.connectionFailed) self.deferred = defer.Deferred()
def main(reactor): cc = ClientCreator(reactor, AMP) d = cc.connectTCP('localhost', 7805) d.addCallback(otpLogin) d.addCallback(add) d.addCallback(display) return d
def connect(self, ip, port, type, connectionLost=None): d=self.d=defer.Deferred() logging.info("Connecting "+ip+", port "+str(port)) c = ClientCreator(reactor, GTA_Client_Protocol) c.connectTCP(ip, port).addCallback(self.gotProtocol).addErrback(self.failed_connection) self.connectionLost = connectionLost self.type = type return d
def connect_start(self): if self.verbose: print 'connect_start' assert self.chat_state == self.NOT_CONNECTED self.connect_sem = defer.Deferred() creator = ClientCreator(reactor, self.Proxy) d = creator.connectTCP(self.host, self.port) d.addCallback(self.connect_finish) d.addErrback(self.handle_remote_error) self.chat_state = self.CONNECTING
def connect(host, port, *args, **keywords): d = defer.Deferred() c = ClientCreator(reactor, UOProtocol, *args, **keywords) e = c.connectTCP(host, port) e.addCallback(lambda client: d.callback(Client(client))) e.addErrback(lambda f: d.errback(f)) return d
def update(self): creator = ClientCreator(reactor, FTPClient, self.username, self.password, passive=self.passive) creator.connectTCP(self.server, self.port).addCallbacks(self.connection_made, self.on_error)
def setRemoteIpCallback(self, ret = False): if ret: self["text"].setText(_("Testing remote connection")) timeout = 3000 self.currentLength = 0 self.total = 0 self.working = True creator = ClientCreator(reactor, FTPClient, config.plugins.RemoteStreamConverter.username.value, config.plugins.RemoteStreamConverter.password.value, config.plugins.RemoteStreamConverter.passive.value) creator.connectTCP(self.getRemoteAdress(), config.plugins.RemoteStreamConverter.port.value, timeout).addCallback(self.controlConnectionMade).addErrback(self.connectionFailed)
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.Set, key=key, value=value)) return d1 # deffer, który zawierać będzie wynik metody set na właściwym serwerze