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
